workflow-ai 1.0.61 → 1.0.63

package/src/lib/agent-spawner.mjs

@@ -0,0 +1,338 @@
+#!/usr/bin/env node
+
+import { spawn, execSync } from 'child_process';
+import path from 'path';
+
+const ResultParser = {
+  STATUS_ALIASES: {
+    pass: 'passed',
+    approved: 'passed',
+    success: 'passed',
+    succeeded: 'passed',
+    ok: 'passed',
+    accepted: 'passed',
+    lgtm: 'passed',
+    fixed: 'passed',
+    resolved: 'passed',
+    fail: 'failed',
+    rejected: 'failed',
+    denied: 'failed',
+    not_passed: 'failed',
+    err: 'error',
+    crash: 'error',
+    timeout: 'error',
+  },
+
+  normalizeStatus(status) {
+    const lower = status.toLowerCase();
+    const canonical = ResultParser.STATUS_ALIASES[lower];
+    if (canonical) {
+      return canonical;
+    }
+    return status;
+  },
+
+  parse(output, stageId) {
+    const marker = '---RESULT---';
+    const startIdx = output.indexOf(marker);
+    const endIdx = startIdx !== -1 ? output.indexOf(marker, startIdx + marker.length) : -1;
+
+    if (startIdx !== -1 && endIdx !== -1) {
+      const resultBlock = output.substring(startIdx + marker.length, endIdx).trim();
+      const data = ResultParser.parseResultBlock(resultBlock);
+      const normalizedStatus = ResultParser.normalizeStatus(data.status || 'default');
+      return {
+        status: normalizedStatus,
+        data: data.data || {},
+        raw: output,
+        parsed: true
+      };
+    }
+
+    return ResultParser.fallbackParse(output, stageId);
+  },
+
+  parseResultBlock(block) {
+    const lines = block.split('\n');
+    const data = {};
+    let status = 'default';
+    let currentKey = null;
+    let multilineValue = null;
+
+    const flushMultiline = () => {
+      if (currentKey !== null && multilineValue !== null) {
+        data[currentKey] = multilineValue.replace(/\n$/, '');
+        currentKey = null;
+        multilineValue = null;
+      }
+    };
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const topLevelMatch = line.match(/^([^:\s][^:]*):\s*(.*)$/);
+
+      if (topLevelMatch) {
+        flushMultiline();
+        const key = topLevelMatch[1].trim();
+        const value = topLevelMatch[2].trim();
+
+        if (value !== '') {
+          if (key === 'status') {
+            status = value;
+          } else {
+            data[key] = value;
+          }
+        } else {
+          currentKey = key;
+          multilineValue = '';
+        }
+      } else if (currentKey !== null && (line.startsWith(' ') || line.startsWith('\t') || line === '')) {
+        multilineValue += line + '\n';
+      } else if (currentKey !== null) {
+        flushMultiline();
+      }
+    }
+
+    flushMultiline();
+    return { status, data };
+  },
+
+  fallbackParse(output, stageId) {
+    const lines = output.split('\n');
+    let status = 'default';
+    const extractedData = {};
+    let inResultSection = false;
+
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      const statusMatch = trimmedLine.match(/^(?:status|Status):\s*(\w+)/i);
+      if (statusMatch) {
+        status = statusMatch[1];
+        inResultSection = true;
+        continue;
+      }
+
+      if (inResultSection) {
+        const dataMatch = trimmedLine.match(/^(\w+):\s*(.+)$/i);
+        if (dataMatch && dataMatch[1].toLowerCase() !== 'status') {
+          extractedData[dataMatch[1]] = dataMatch[2];
+        }
+      }
+    }
+
+    if (status === 'default') {
+      const lowerOutput = output.toLowerCase();
+      if (lowerOutput.includes('completed') || lowerOutput.includes('success') || lowerOutput.includes('done')) {
+        status = 'default';
+        extractedData._inferred = 'success_keywords';
+      } else if (lowerOutput.includes('error') || lowerOutput.includes('failed')) {
+        status = 'error';
+        extractedData._inferred = 'error_keywords';
+      }
+    }
+
+    const normalizedStatus = ResultParser.normalizeStatus(status);
+    return {
+      status: normalizedStatus,
+      data: extractedData,
+      raw: output,
+      parsed: false
+    };
+  }
+};
+
+export async function spawnAgent(agentConfig, prompt, options = {}) {
+  const {
+    timeout = 300,
+    logger = null,
+    resultParser = ResultParser,
+    stageId = 'unknown',
+    skillId = null,
+    projectRoot = process.cwd(),
+    currentChildRef = null
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = [...agentConfig.args];
+    const finalPrompt = prompt;
+
+    const useShell = process.platform === 'win32' && agentConfig.command !== 'node';
+    const useStdin = useShell && finalPrompt.includes('\n');
+
+    if (!useStdin) {
+      args.push(finalPrompt);
+    }
+
+    if (logger) {
+      const displayArgs = skillId ? [...args.slice(0, -1), skillId] : args;
+      logger.info(`RUN ${agentConfig.command} ${displayArgs.join(' ')}`, stageId);
+      const promptLines = prompt.split('\n').filter(l => l.trim());
+      if (promptLines.length > 1) {
+        for (const line of promptLines.slice(1)) {
+          logger.info(`  ${line}`, stageId);
+        }
+      }
+    }
+
+    const startTime = Date.now();
+
+    const child = spawn(agentConfig.command, args, {
+      cwd: path.resolve(projectRoot, agentConfig.workdir || '.'),
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: useShell
+    });
+
+    if (currentChildRef) {
+      currentChildRef.current = child;
+    }
+
+    if (useStdin) {
+      child.stdin.write(finalPrompt);
+      child.stdin.end();
+    } else {
+      child.stdin.end();
+    }
+
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      if (process.platform === 'win32' && child.pid) {
+        try { execSync(`taskkill /pid ${child.pid} /T /F`, { stdio: 'pipe' }); } catch {}
+      } else {
+        child.kill('SIGTERM');
+      }
+      if (logger) {
+        logger.timeout(stageId, timeout);
+      }
+      reject(new Error(`Stage "${stageId}" timed out after ${timeout}s`));
+    }, timeout * 1000);
+
+    let stdoutBuffer = '';
+    let agentText = '';
+    child.stdout.on('data', (data) => {
+      const chunk = data.toString();
+      stdout += chunk;
+      stdoutBuffer += chunk;
+      const lines = stdoutBuffer.split('\n');
+      stdoutBuffer = lines.pop();
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          if (obj.type === 'content_block_delta' && obj.delta?.text) {
+            process.stdout.write(obj.delta.text);
+            agentText += obj.delta.text;
+          } else if (obj.type === 'assistant' && obj.message?.content) {
+            for (const block of obj.message.content) {
+              if (block.type === 'text' && block.text) {
+                process.stdout.write(block.text);
+                agentText += block.text;
+              }
+            }
+          }
+        } catch {
+          process.stdout.write(line + '\n');
+          agentText += line + '\n';
+        }
+      }
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+      process.stderr.write(data);
+    });
+
+    child.on('close', (code) => {
+      if (currentChildRef) {
+        currentChildRef.current = null;
+      }
+      clearTimeout(timeoutId);
+      const durationMs = Date.now() - startTime;
+
+      if (stdoutBuffer.trim()) {
+        try {
+          const obj = JSON.parse(stdoutBuffer);
+          if (obj.type === 'content_block_delta' && obj.delta?.text) {
+            process.stdout.write(obj.delta.text);
+          }
+        } catch {
+          process.stdout.write(stdoutBuffer + '\n');
+        }
+      }
+      process.stdout.write('\n');
+
+      if (timedOut) return;
+
+      if (logger) {
+        logger.cliCall(agentConfig.command, args, code);
+        const trimmedOutput = agentText.trim();
+        if (trimmedOutput) {
+          logger.info(`OUTPUT ↓`, stageId);
+          for (const line of trimmedOutput.split('\n')) {
+            logger.info(`  ${line}`, stageId);
+          }
+          logger.info(`OUTPUT ↑`, stageId);
+        }
+        if (stderr.trim()) {
+          logger.warn(`STDERR ↓`, stageId);
+          for (const line of stderr.trim().split('\n')) {
+            logger.warn(`  ${line}`, stageId);
+          }
+          logger.warn(`STDERR ↑`, stageId);
+        }
+      }
+
+      const result = resultParser.parse(stdout, stageId);
+
+      if (code !== 0 && result.parsed && result.status && result.status !== 'default') {
+        if (logger) {
+          logger.warn(
+            `Agent exited with code ${code}, but RESULT was parsed (status: ${result.status}). Using parsed result.`,
+            stageId
+          );
+        }
+      } else if (code !== 0) {
+        const err = new Error(`Agent exited with code ${code}`);
+        err.code = 'NON_ZERO_EXIT';
+        err.exitCode = code;
+        err.stderr = stderr;
+        if (logger) {
+          logger.error(`Agent exited with code ${code}`, stageId);
+          if (stderr.trim()) {
+            for (const line of stderr.trim().split('\n')) {
+              logger.error(`  stderr: ${line}`, stageId);
+            }
+          }
+        }
+        reject(err);
+        return;
+      }
+
+      resolve({
+        status: result.status || 'default',
+        output: stdout,
+        stderr: stderr,
+        result: result.data || {},
+        exitCode: code,
+        parsed: result.parsed,
+        durationMs
+      });
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timeoutId);
+      if (!timedOut) {
+        if (logger) {
+          logger.error(`CLI error: ${err.message}`, stageId);
+        }
+        reject(err);
+      }
+    });
+  });
+}
+
+export { ResultParser };
+export default { spawnAgent, ResultParser };

package/src/runner.mjs

@@ -429,11 +429,21 @@ class ResultParser {
   parse(output, stageId) {
     const marker = '---RESULT---';
 
-    // Попытка найти парные маркеры
-    const startIdx = output.indexOf(marker);
-    const endIdx = startIdx !== -1 ? output.indexOf(marker, startIdx + marker.length) : -1;
+    // Ищем маркеры ТОЛЬКО на отдельных строках (printResult выводит их на своих строках).
+    // Берём последнюю пару: маркер может случайно встретиться в логах/заголовках тикетов
+    // до финального блока (напр. "title: ... ---RESULT--- ..."). Regex ^---RESULT---$
+    // с multi-line флагом отсеивает такие вхождения.
+    const lineMarkerRegex = /^---RESULT---\s*$/gm;
+    const markerPositions = [];
+    let m;
+    while ((m = lineMarkerRegex.exec(output)) !== null) {
+      markerPositions.push(m.index);
+    }
+
+    const endIdx = markerPositions.length >= 2 ? markerPositions[markerPositions.length - 1] : -1;
+    const startIdx = markerPositions.length >= 2 ? markerPositions[markerPositions.length - 2] : -1;
 
-    if (startIdx !== -1 && endIdx !== -1) {
+    if (startIdx !== -1 && endIdx !== -1 && startIdx !== endIdx) {
       // Найдены маркеры — парсим структурированный блок
       const resultBlock = output.substring(startIdx + marker.length, endIdx).trim();
       const data = this.parseResultBlock(resultBlock);
@@ -921,16 +931,8 @@ class StageExecutor {
       };
     }
 
-    // Курсор = (attempt - 1), clamped
-    const cursor = attempt - 1;
-    if (cursor >= compatible.length) {
-      return {
-        blocked: 'attempts_exhausted',
-        reason: `Attempt ${attempt} exceeds compatible agents list length (${compatible.length})`,
-        attempt,
-        triedAgents: compatible
-      };
-    }
+    // Курсор = (attempt - 1) % length — ротация по кругу
+    const cursor = (attempt - 1) % compatible.length;
 
     const agentId = compatible[cursor];
     // Клонируем stage с подменой instructions (для agents_by_type override)

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