workflow-ai 1.0.55 → 1.0.57

package/configs/pipeline.yaml

@@ -144,6 +144,9 @@ pipeline:
   #     counter:        <string>   — имя счётчика попыток для этого stage
   #     agent_by_type:             — маршрутизация агента по типу задачи (task_type)
   #       <type>: <agent-id>       — например: impl: claude-sonnet, arch: claude-opus
+  #       <type>:                  — или расширенный формат с fallback_model:
+  #         agent: <agent-id>
+  #         fallback_model: <agent-id>
   #     agent_by_attempt:          — ротация агента по номеру попытки
   #       <N>: <agent-id>          — например: 1: qwen-code, 2: claude-sonnet
   #     goto:                      — логика переходов по результату
@@ -348,14 +351,21 @@ pipeline:
       skill: execute-task
       counter: task_attempts
       agent_by_type:
-        coach: claude-coach
-        qa: claude-qa
-        impl: kilo-minimax
-      # fix: claude-sonnet
-        arch: claude-opus
-      # review: qwen-code
-      # docs: qwen-code
-        admin: kilo-minimax
+        coach:
+          agent: claude-coach
+          fallback_model: claude-sonnet
+        qa:
+          agent: claude-qa
+          fallback_model: claude-sonnet
+        impl:
+          agent: kilo-minimax
+          fallback_model: kilo-glm
+        arch:
+          agent: claude-opus
+          fallback_model: claude-sonnet
+        admin:
+          agent: kilo-minimax
+          fallback_model: kilo-glm
       agent_by_attempt:
         2: qwen-code
         3: claude-sonnet

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workflow-ai",
-  "version": "1.0.55",
+  "version": "1.0.57",
   "description": "AI Agent Workflow Coordinator — kanban-based pipeline for AI coding agents",
   "type": "module",
   "bin": {

package/src/runner.mjs

@@ -796,6 +796,7 @@ class StageExecutor {
     // 3. stage.agent — явно указанный агент stage
     // 4. default_agent — глобальный дефолт
     let agentId = stage.agent || this.pipeline.default_agent;
+    let fallbackModelId = stage.fallback_agent;  // fallback_model из agent_by_type имеет приоритет
     const attempt = (stage.counter && this.counters[stage.counter]) || 0;
 
     // Фоллбэк: если task_type не задан, вычисляем из префикса ticket_id (PMA-005 → pma)
@@ -805,8 +806,17 @@ class StageExecutor {
 
     if (attempt <= 1 && stage.agent_by_type && taskType) {
       // Первая попытка: выбор по типу задачи
-      if (stage.agent_by_type[taskType]) {
-        agentId = stage.agent_by_type[taskType];
+      const agentConfig = stage.agent_by_type[taskType];
+      if (agentConfig) {
+        // Поддержка формата: { agent: string, fallback_model: string } или просто string
+        if (typeof agentConfig === 'object' && agentConfig.agent) {
+          agentId = agentConfig.agent;
+          if (agentConfig.fallback_model) {
+            fallbackModelId = agentConfig.fallback_model;
+          }
+        } else {
+          agentId = agentConfig;
+        }
         if (this.logger) {
           this.logger.info(`Agent by type: task_type="${taskType}" → ${agentId}`, stageId);
         }
@@ -844,8 +854,8 @@ class StageExecutor {
       this.fileGuard.takeSnapshot();
     }
 
-    // Вызываем CLI-агента с поддержкой fallback
-    const result = await this.callAgentWithFallback(agent, prompt, stageId, stage.skill, stage.fallback_agent);
+    // Вызываем CLI-агента с поддержкой fallback (приоритет: fallback_model из agent_by_type > stage.fallback_agent)
+    const result = await this.callAgentWithFallback(agent, prompt, stageId, stage.skill, fallbackModelId);
 
     // Логгируем завершение stage
     if (this.logger) {
@@ -1020,6 +1030,15 @@ class StageExecutor {
             }
             this.logger.info(`OUTPUT ↑`, stageId);
           }
+
+          // Логгируем stderr независимо от exit code
+          if (stderr.trim()) {
+            this.logger.warn(`STDERR ↓`, stageId);
+            for (const line of stderr.trim().split('\n')) {
+              this.logger.warn(`  ${line}`, stageId);
+            }
+            this.logger.warn(`STDERR ↑`, stageId);
+          }
         }
 
         // Парсим результат из вывода агента через ResultParser

package/src/scripts/archive-plan-tickets.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+/**
+ * archive-plan-tickets.js - Архивирует все done-тикеты указанного плана
+ *
+ * Использование:
+ *   node archive-plan-tickets.js <plan_id>
+ *
+ * Пример:
+ *   node archive-plan-tickets.js PLAN-002
+ *   node archive-plan-tickets.js 2
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { findProjectRoot } from 'workflow-ai/lib/find-root.mjs';
+import { parseFrontmatter, serializeFrontmatter, normalizePlanId, extractPlanId, printResult } from 'workflow-ai/lib/utils.mjs';
+
+const PROJECT_DIR = findProjectRoot();
+const WORKFLOW_DIR = path.join(PROJECT_DIR, '.workflow');
+const TICKETS_DIR = path.join(WORKFLOW_DIR, 'tickets');
+const DONE_DIR = path.join(TICKETS_DIR, 'done');
+const ARCHIVE_DIR = path.join(TICKETS_DIR, 'archive');
+
+/**
+ * Архивирует все done-тикеты указанного плана
+ */
+function archivePlanTickets(planId) {
+  if (!planId) {
+    return { status: 'error', error: 'Missing plan_id' };
+  }
+
+  if (!fs.existsSync(DONE_DIR)) {
+    return { status: 'ok', plan_id: planId, archived: 0, ticket_ids: '' };
+  }
+
+  if (!fs.existsSync(ARCHIVE_DIR)) {
+    fs.mkdirSync(ARCHIVE_DIR, { recursive: true });
+  }
+
+  const files = fs.readdirSync(DONE_DIR).filter(f => f.endsWith('.md') && f !== '.gitkeep.md');
+  const archived = [];
+
+  for (const file of files) {
+    const filePath = path.join(DONE_DIR, file);
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const { frontmatter, body } = parseFrontmatter(content);
+
+      const ticketPlanId = normalizePlanId(frontmatter.parent_plan);
+      if (ticketPlanId !== planId) continue;
+
+      const ticketId = frontmatter.id || file.replace('.md', '');
+
+      frontmatter.updated_at = new Date().toISOString();
+      frontmatter.archived_at = new Date().toISOString();
+
+      const destPath = path.join(ARCHIVE_DIR, file);
+      fs.writeFileSync(destPath, serializeFrontmatter(frontmatter) + body, 'utf8');
+      fs.unlinkSync(filePath);
+
+      archived.push(ticketId);
+      console.log(`[ARCHIVE] ${ticketId}: done → archive`);
+    } catch (e) {
+      console.error(`[ERROR] Failed to archive ${file}: ${e.message}`);
+    }
+  }
+
+  return {
+    status: 'ok',
+    plan_id: planId,
+    archived: archived.length,
+    ticket_ids: archived.join(',')
+  };
+}
+
+// Main entry point
+const rawArgs = process.argv.slice(2);
+let planId;
+
+if (rawArgs.length >= 1) {
+  // Прямой вызов или pipeline context
+  const arg = rawArgs[0];
+  const planMatch = arg.match(/plan_id:\s*(\S+)/i);
+  planId = planMatch ? normalizePlanId(planMatch[1]) : normalizePlanId(arg);
+} else {
+  planId = extractPlanId();
+}
+
+if (!planId) {
+  console.error('Usage: node archive-plan-tickets.js <plan_id>');
+  console.error('Example: node archive-plan-tickets.js PLAN-002');
+  printResult({ status: 'error', error: 'Missing plan_id argument' });
+  process.exit(1);
+}
+
+const result = archivePlanTickets(planId);
+printResult(result);
+
+if (result.status === 'error') {
+  process.exit(1);
+}

package/src/scripts/check-anomalies.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+/**
+ * check-anomalies.js - Скрипт для проверки аномалий в тикетах
+ *
+ * Проверяет in-progress тикеты на наличие заполненных результатов.
+ * Если тикет в in-progress, но имеет заполненный раздел "Результат выполнения" —
+ * это аномалия (тикет, вероятно, выполнен, но не перемещён в done/review).
+ *
+ * Использование:
+ *   node check-anomalies.js
+ *
+ * Выводит результат в формате:
+ *   ---RESULT---
+ *   status: ok|anomalies_found|error
+ *   anomalies_count: N
+ *   anomalies: [{"id": "IMPL-001", "title": "...", "recommendation": "..."}]
+ *   ---RESULT---
+ */
+
+import fs from 'fs';
+import path from 'path';
+import YAML from 'workflow-ai/lib/js-yaml.mjs';
+import { findProjectRoot } from 'workflow-ai/lib/find-root.mjs';
+import { parseFrontmatter, printResult } from 'workflow-ai/lib/utils.mjs';
+
+// Корень проекта
+const PROJECT_DIR = findProjectRoot();
+const TICKETS_DIR = path.join(PROJECT_DIR, '.workflow', 'tickets');
+const IN_PROGRESS_DIR = path.join(TICKETS_DIR, 'in-progress');
+
+/**
+ * Проверяет, заполнен ли раздел результатов
+ * Возвращает true, если раздел содержит реальный контент (не только комментарии)
+ */
+function hasFilledResult(body) {
+  // Ищем раздел "Результат выполнения" или "Result"
+  // Используем более гибкий паттерн
+  const resultSectionRegex = /^##\s*(Результат выполнения|Result)\s*$/m;
+  const sectionStart = body.search(resultSectionRegex);
+
+  if (sectionStart === -1) {
+    return false;
+  }
+
+  // Находим начало следующей секции ## или конец файла
+  const nextSectionRegex = /^##\s+/gm;
+  nextSectionRegex.lastIndex = sectionStart + 1;
+  const nextSectionMatch = nextSectionRegex.exec(body);
+  const sectionEnd = nextSectionMatch ? nextSectionMatch.index : body.length;
+
+  const sectionContent = body.substring(sectionStart, sectionEnd);
+
+  // Ищем подраздел Summary или "Что сделано"
+  const summaryRegex = /^###\s*(Summary|Что сделано)\s*$/m;
+  const summaryStart = sectionContent.search(summaryRegex);
+
+  if (summaryStart === -1) {
+    return false;
+  }
+
+  // Находим начало следующего подраздела ### или конец секции
+  const nextSubsectionRegex = /^###\s+/gm;
+  nextSubsectionRegex.lastIndex = summaryStart + 1;
+  const nextSubsectionMatch = nextSubsectionRegex.exec(sectionContent);
+  const summaryEnd = nextSubsectionMatch ? nextSubsectionMatch.index : sectionContent.length;
+
+  const summaryContent = sectionContent.substring(summaryStart, summaryEnd);
+
+  // Проверяем, что контент не пустой и не состоит только из комментариев
+  // Удаляем HTML комментарии и проверяем остаток
+  const withoutComments = summaryContent.replace(/<!--[\s\S]*?-->/g, '').trim();
+
+  // Если после удаления комментариев остался текст — раздел заполнен
+  return withoutComments.length > 0;
+}
+
+/**
+ * Основная функция проверки аномалий
+ */
+async function checkAnomalies() {
+  const anomalies = [];
+
+  // Проверяем существование директории in-progress
+  if (!fs.existsSync(IN_PROGRESS_DIR)) {
+    return {
+      status: 'ok',
+      anomalies_count: 0,
+      anomalies: [],
+      message: 'in-progress directory does not exist'
+    };
+  }
+
+  // Читаем все файлы в in-progress
+  let files;
+  try {
+    files = fs.readdirSync(IN_PROGRESS_DIR);
+  } catch (e) {
+    return {
+      status: 'error',
+      error: `Failed to read in-progress directory: ${e.message}`
+    };
+  }
+
+  // Фильтруем .md файлы (исключаем .gitkeep)
+  const ticketFiles = files.filter(f => f.endsWith('.md') && f !== '.gitkeep.md');
+
+  for (const file of ticketFiles) {
+    const filePath = path.join(IN_PROGRESS_DIR, file);
+    let content;
+
+    try {
+      content = fs.readFileSync(filePath, 'utf8');
+    } catch (e) {
+      anomalies.push({
+        id: file.replace('.md', ''),
+        title: 'Unknown (read error)',
+        recommendation: `Не удалось прочитать файл: ${e.message}`
+      });
+      continue;
+    }
+
+    // Парсим frontmatter для получения id и title
+    const { frontmatter, body } = parseFrontmatter(content);
+    const ticketId = frontmatter.id || file.replace('.md', '');
+    const ticketTitle = frontmatter.title || 'Unknown';
+
+    // Проверяем наличие заполненного результата
+    if (hasFilledResult(body)) {
+      anomalies.push({
+        id: ticketId,
+        title: ticketTitle,
+        recommendation: 'Проверьте тикет и переместите в done/ или review/ если выполнен'
+      });
+    }
+  }
+
+  return {
+    status: anomalies.length > 0 ? 'anomalies_found' : 'ok',
+    anomalies_count: anomalies.length,
+    anomalies: anomalies
+  };
+}
+
+// Main entry point
+checkAnomalies().then(result => {
+  printResult(result);
+
+  // Если найдены аномалии, выводим их в читаемом виде
+  if (result.anomalies && result.anomalies.length > 0) {
+    console.log('\n[ANOMALIES DETECTED]');
+    for (const anomaly of result.anomalies) {
+      console.log(`  - ${anomaly.id}: ${anomaly.title}`);
+      console.log(`    Recommendation: ${anomaly.recommendation}`);
+    }
+  }
+
+  if (result.status === 'error') {
+    process.exit(1);
+  }
+});

package/src/scripts/check-conditions.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+
+/**
+ * check-conditions.js — Проверяет условия тикетов в backlog/ и выводит список готовых
+ *
+ * Использование:
+ *   node check-conditions.js
+ *
+ * Выводит результат в формате:
+ *   ---RESULT---
+ *   status: has_ready
+ *   ready_tickets: IMPL-002, DOCS-001
+ *   ---RESULT---
+ *
+ * или если готовых нет, но есть тикеты в ready/:
+ *   ---RESULT---
+ *   status: default
+ *   ready_tickets:
+ *   ---RESULT---
+ *
+ * или если backlog пуст и нет тикетов в ready/:
+ *   ---RESULT---
+ *   status: empty
+ *   ready_tickets:
+ *   ---RESULT---
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { findProjectRoot } from 'workflow-ai/lib/find-root.mjs';
+import { parseFrontmatter, printResult, normalizePlanId, extractPlanId, serializeFrontmatter } from 'workflow-ai/lib/utils.mjs';
+
+const PROJECT_DIR = findProjectRoot();
+const WORKFLOW_DIR = path.join(PROJECT_DIR, '.workflow');
+const TICKETS_DIR = path.join(WORKFLOW_DIR, 'tickets');
+const BACKLOG_DIR = path.join(TICKETS_DIR, 'backlog');
+const READY_DIR = path.join(TICKETS_DIR, 'ready');
+const DONE_DIR = path.join(TICKETS_DIR, 'done');
+
+/**
+ * Проверяет одно условие тикета
+ */
+function checkCondition(condition) {
+  const { type, value } = condition;
+
+  switch (type) {
+    case 'file_exists':
+      return fs.existsSync(path.join(PROJECT_DIR, value));
+
+    case 'file_not_exists':
+      return !fs.existsSync(path.join(PROJECT_DIR, value));
+
+    case 'tasks_completed': {
+      if (!value || (Array.isArray(value) && value.length === 0)) return true;
+      const ids = Array.isArray(value) ? value : [value];
+      return ids.every(taskId => fs.existsSync(path.join(DONE_DIR, `${taskId}.md`)));
+    }
+
+    case 'date_after':
+      return new Date() > new Date(value);
+
+    case 'date_before':
+      return new Date() < new Date(value);
+
+    case 'manual_approval':
+      return false;
+
+    default:
+      console.error(`[WARN] Unknown condition type: ${type}`);
+      return true;
+  }
+}
+
+/**
+ * Проверяет зависимости тикета
+ */
+function checkDependencies(dependencies) {
+  if (!dependencies || dependencies.length === 0) return true;
+  return dependencies.every(depId => fs.existsSync(path.join(DONE_DIR, `${depId}.md`)));
+}
+
+/**
+ * Считывает все тикеты из директории
+ */
+function readTickets(dir) {
+  if (!fs.existsSync(dir)) return [];
+
+  const tickets = [];
+  const files = fs.readdirSync(dir).filter(f => f.endsWith('.md') && f !== '.gitkeep.md');
+
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const { frontmatter } = parseFrontmatter(content);
+      tickets.push({ id: frontmatter.id || file.replace('.md', ''), frontmatter });
+    } catch (e) {
+      console.error(`[WARN] Failed to read ticket ${file}: ${e.message}`);
+    }
+  }
+
+  return tickets;
+}
+
+/**
+ * Перемещает тикет из ready/ в backlog/
+ */
+function demoteToBacklog(ticketId) {
+  const sourcePath = path.join(READY_DIR, `${ticketId}.md`);
+  const targetPath = path.join(BACKLOG_DIR, `${ticketId}.md`);
+
+  if (!fs.existsSync(sourcePath)) {
+    console.error(`[WARN] ${ticketId}: not found in ready/, skipping`);
+    return false;
+  }
+
+  const content = fs.readFileSync(sourcePath, 'utf8');
+  const { frontmatter, body } = parseFrontmatter(content);
+
+  frontmatter.updated_at = new Date().toISOString();
+
+  const newContent = serializeFrontmatter(frontmatter) + body;
+
+  if (!fs.existsSync(BACKLOG_DIR)) {
+    fs.mkdirSync(BACKLOG_DIR, { recursive: true });
+  }
+
+  fs.renameSync(sourcePath, targetPath);
+  fs.writeFileSync(targetPath, newContent, 'utf8');
+  return true;
+}
+
+/**
+ * Проверяет все тикеты в backlog/ и возвращает список готовых
+ */
+function checkBacklog(planId) {
+  const allTickets = readTickets(BACKLOG_DIR);
+  const tickets = planId
+    ? allTickets.filter(t => normalizePlanId(t.frontmatter.parent_plan) === planId)
+    : allTickets;
+
+  const ready = [];
+  const waiting = [];
+
+  for (const ticket of tickets) {
+    const { frontmatter, id } = ticket;
+
+    const conditions = frontmatter.conditions || [];
+    const dependencies = frontmatter.dependencies || [];
+
+    const depsMet = checkDependencies(dependencies);
+    const conditionsMet = conditions.every(checkCondition);
+
+    if (depsMet && conditionsMet) {
+      ready.push(id);
+      if (frontmatter.type === 'human') {
+        console.log(`[INFO] ${id}: type is 'human', moved to ready/ (requires manual execution)`);
+      }
+    } else {
+      const reasons = [];
+      if (!depsMet) reasons.push(`ждёт зависимости: ${dependencies.join(', ')}`);
+      conditions.forEach(c => {
+        if (!checkCondition(c)) reasons.push(`условие не выполнено: ${c.type}`);
+      });
+      waiting.push({ id, reasons });
+    }
+  }
+
+  return { ready, waiting, total: tickets.length };
+}
+
+/**
+ * Проверяет тикеты в ready/ и возвращает тикеты в backlog при невыполненных условиях
+ */
+function checkReady(planId) {
+  const allTickets = readTickets(READY_DIR);
+  const tickets = planId
+    ? allTickets.filter(t => normalizePlanId(t.frontmatter.parent_plan) === planId)
+    : allTickets;
+
+  const demoted = [];
+
+  for (const ticket of tickets) {
+    const { frontmatter, id } = ticket;
+    const conditions = frontmatter.conditions || [];
+    const dependencies = frontmatter.dependencies || [];
+
+    const depsMet = checkDependencies(dependencies);
+    const conditionsMet = conditions.every(checkCondition);
+
+    if (!depsMet || !conditionsMet) {
+      if (demoteToBacklog(id)) {
+        console.log(`[INFO] ${id}: ready/ → backlog/ (условия не выполнены)`);
+        demoted.push(id);
+      }
+    }
+  }
+
+  return { demoted, total: tickets.length };
+}
+
+async function main() {
+  const planId = extractPlanId();
+
+  if (planId) {
+    console.log(`[INFO] Filtering by plan_id: ${planId}`);
+  }
+
+  // Сначала демотирование невалидных тикетов из ready/
+  console.log(`[INFO] Checking ready/ for invalid tickets: ${READY_DIR}`);
+  const { demoted, total: readyTotal } = checkReady(planId);
+  console.log(`[INFO] Total in ready/${planId ? ` (plan ${planId})` : ''}: ${readyTotal}`);
+  console.log(`[INFO] Demoted to backlog: ${demoted.length}`);
+
+  // Затем проверка backlog — демотированные тикеты сразу переоцениваются
+  console.log(`[INFO] Scanning backlog/: ${BACKLOG_DIR}`);
+
+  const { ready, waiting, total } = checkBacklog(planId);
+
+  console.log(`[INFO] Total in backlog${planId ? ` (plan ${planId})` : ''}: ${total}`);
+  console.log(`[INFO] Ready: ${ready.length}, Waiting: ${waiting.length}`);
+
+  if (ready.length > 0) {
+    console.log(`[INFO] Ready tickets: ${ready.join(', ')}`);
+  }
+
+  for (const { id, reasons } of waiting) {
+    console.log(`[INFO] ${id}: ${reasons.join('; ')}`);
+  }
+
+  if (ready.length > 0) {
+    printResult({ status: 'has_ready', ready_tickets: ready.join(', '), demoted_tickets: demoted.join(', ') });
+    return;
+  }
+
+  // Нет готовых — проверяем есть ли что-то в ready/
+  const readyDirTickets = readTickets(READY_DIR);
+  if (readyDirTickets.length > 0) {
+    console.log(`[INFO] No new ready tickets, but ready/ has ${readyDirTickets.length} ticket(s)`);
+    printResult({ status: 'default', ready_tickets: '', demoted_tickets: demoted.join(', ') });
+  } else {
+    console.log('[INFO] No ready tickets and ready/ is empty');
+    printResult({ status: 'empty', ready_tickets: '', demoted_tickets: demoted.join(', ') });
+  }
+}
+
+main().catch(e => {
+  console.error(`[ERROR] ${e.message}`);
+  printResult({ status: 'error', error: e.message });
+  process.exit(1);
+});