workflow-ai 1.2.1 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workflow-ai",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "AI Agent Workflow Coordinator — kanban-based pipeline for AI coding agents",
   "type": "module",
   "bin": {
@@ -36,9 +36,19 @@
   "scripts": {
     "test": "node --test src/tests/*.test.mjs",
     "test:skills": "node src/scripts/run-skill-tests.js --all",
+    "coverage": "c8 node --test src/tests/*.test.mjs",
+    "coverage:mark-blocked": "c8 node --test src/tests/scripts-mark-blocked.test.mjs",
+    "coverage:pick-next-task": "node scripts/coverage-pick-next-task.js",
+    "coverage:move-ticket": "c8 node --test src/tests/scripts-move-ticket-approval-hook.test.mjs",
+    "mutation-test": "stryker run",
     "release": "npm version patch && npm publish"
   },
   "dependencies": {
     "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@stryker-mutator/core": "^9.6.1",
+    "@stryker-mutator/javascript-mutator": "^4.0.0",
+    "c8": "^11.0.0"
   }
 }

package/src/lib/marker.mjs

@@ -0,0 +1,108 @@
+import fs from 'fs';
+import path from 'path';
+
+const MARKER_FILE = '.pipeline.lock';
+const LOGS_DIR = '.workflow/logs';
+
+/**
+ * Ensures the logs directory exists
+ */
+function ensureLogsDir(projectRoot) {
+  const logsPath = path.join(projectRoot, LOGS_DIR);
+  if (!fs.existsSync(logsPath)) {
+    fs.mkdirSync(logsPath, { recursive: true });
+  }
+}
+
+/**
+ * Atomic write via temp file + rename.
+ * Fallback to O_EXCL (wx flag) on EXDEV/ENOTSUP.
+ * Throws Error if marker file already exists (to prevent race conditions).
+ */
+export function writeMarker(projectRoot, payload) {
+  ensureLogsDir(projectRoot);
+  const markerPath = path.join(projectRoot, LOGS_DIR, MARKER_FILE);
+  const content = JSON.stringify(payload, null, 2);
+
+  // First, try exclusive create (O_EXCL) - this guarantees atomicity
+  // and prevents race conditions where two processes both think they created the marker
+  try {
+    const fd = fs.openSync(markerPath, 'wx');
+    fs.writeFileSync(fd, content, 'utf-8');
+    fs.closeSync(fd);
+    return;
+  } catch (openErr) {
+    if (openErr.code === 'EEXIST') {
+      // Marker already exists - another process created it
+      throw new Error(`Marker file already exists at ${markerPath}`);
+    }
+    // If EXDEV/ENOTSUP (cross-device link), fall back to temp+rename
+    if (openErr.code !== 'EXDEV' && openErr.code !== 'ENOTSUP') {
+      throw openErr;
+    }
+  }
+
+  // Fallback: temp file + rename (less atomic but works across devices)
+  const tempPath = markerPath + '.tmp.' + process.pid + '.' + Date.now();
+  try {
+    fs.writeFileSync(tempPath, content, 'utf-8');
+    fs.renameSync(tempPath, markerPath);
+    return;
+  } catch (renameErr) {
+    // Cleanup temp file if it still exists
+    try {
+      fs.unlinkSync(tempPath);
+    } catch {
+      // ignore
+    }
+
+    // If rename failed because marker was created by another process in the meantime
+    if (renameErr.code === 'EEXIST' || !fs.existsSync(tempPath)) {
+      throw new Error(`Marker file already exists at ${markerPath}`);
+    }
+
+    throw renameErr;
+  }
+}
+
+/**
+ * Reads and parses marker file. Returns null if file doesn't exist or is invalid.
+ */
+export function readMarker(projectRoot) {
+  const markerPath = path.join(projectRoot, LOGS_DIR, MARKER_FILE);
+  try {
+    const data = fs.readFileSync(markerPath, 'utf-8');
+    return JSON.parse(data);
+  } catch (err) {
+    // ENOENT (file missing) or SyntaxError (invalid JSON) → return null
+    return null;
+  }
+}
+
+/**
+ * Silently removes marker file. Ignores ENOENT.
+ */
+export function removeMarker(projectRoot) {
+  const markerPath = path.join(projectRoot, LOGS_DIR, MARKER_FILE);
+  try {
+    fs.unlinkSync(markerPath);
+  } catch (err) {
+    // Ignore ENOENT — file already gone
+    if (err.code !== 'ENOENT') {
+      // Log warning but don't throw — silent unlink
+      console.warn(`[marker] failed to remove ${markerPath}: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Validates that marker exists and its pid matches expectedPid.
+ * Returns true only if both conditions hold, false otherwise.
+ */
+export function validateMarker(projectRoot, expectedPid) {
+  const marker = readMarker(projectRoot);
+  if (!marker) {
+    return false;
+  }
+  return marker.pid === expectedPid;
+}

package/src/lib/process-alive.mjs

@@ -0,0 +1,11 @@
+export function processAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0); // signal 0: existence check, не убивает процесс
+    return true;
+  } catch (err) {
+    // ESRCH = no process; EPERM = process exists but no permission
+    if (err.code === 'EPERM') return true;
+    return false;
+  }
+}

package/src/lib/stop-command.mjs

@@ -0,0 +1,82 @@
+import { readMarker, removeMarker } from './marker.mjs';
+import { processAlive } from './process-alive.mjs';
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+
+/**
+ * Sleep helper
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Gracefully stops a running pipeline.
+ *
+ * @param {string} projectRoot - Absolute path to project root
+ * @param {object} options - Options
+ * @param {number} [options.graceSec=10] - Grace period in seconds before SIGKILL
+ * @returns {object} Result object
+ *   - { ok: true, pid: number, escalated: boolean, duration_ms: number } on success
+ *   - { ok: true, was_stale: true } if marker existed but process was dead
+ *   - { ok: false, code: 'NOT_RUNNING' } if no marker found
+ */
+export async function stopPipeline(projectRoot, options = {}) {
+  const graceSec = options.graceSec ?? 10;
+  const marker = readMarker(projectRoot);
+
+  if (!marker) {
+    return { ok: false, code: 'NOT_RUNNING' };
+  }
+
+  if (!processAlive(marker.pid)) {
+    removeMarker(projectRoot);
+    return { ok: true, was_stale: true };
+  }
+
+  const startMs = Date.now();
+  const isWindows = process.platform === 'win32';
+
+  if (isWindows) {
+    // taskkill /T /F /PID <pid> — kills process tree immediately (forceful)
+    // No graceful period on Windows — taskkill /T does tree kill in one shot
+    try {
+      execSync(`taskkill /T /F /PID ${marker.pid}`, { stdio: 'ignore' });
+    } catch (err) {
+      // Ignore errors — process may have exited already
+    }
+  } else {
+    // POSIX: send SIGTERM, wait, then escalate to SIGKILL if needed
+    try {
+      process.kill(marker.pid, 'SIGTERM');
+    } catch (err) {
+      // Process may have exited between check and kill
+    }
+
+    let escalated = false;
+    const deadline = Date.now() + graceSec * 1000;
+
+    while (processAlive(marker.pid)) {
+      if (Date.now() >= deadline) {
+        try {
+          process.kill(marker.pid, 'SIGKILL');
+          escalated = true;
+        } catch (err) {
+          // Process may have already exited
+        }
+        break;
+      }
+      await sleep(200);
+    }
+  }
+
+  // Ensure marker is removed
+  removeMarker(projectRoot);
+
+  return {
+    ok: true,
+    pid: marker.pid,
+    escalated: isWindows ? false : (escalated || false),
+    duration_ms: Date.now() - startMs
+  };
+}

package/src/runner.mjs

@@ -9,6 +9,7 @@ import { findProjectRoot } from './lib/find-root.mjs';
 import { loadRules, scanStderrForFatalRule, classify } from './lib/error-classifier.mjs';
 import { snapshot, diff, isEmpty } from './lib/artifact-snapshot.mjs';
 import { markUnhealthy, isHealthy } from './lib/agent-health-registry.mjs';
+import { writeMarker, removeMarker } from './lib/marker.mjs';
 
 // ============================================================================
 // Logger — система логирования с уровнями DEBUG/INFO/WARN/ERROR
@@ -176,7 +177,8 @@ class Logger {
    */
   stageStart(stageId, agentId, skillId) {
     this.stats.stagesStarted++;
-    this.info(`START stage="${stageId}" agent="${agentId}" skill="${skillId}"`, stageId);
+    const ticketInfo = this.context && this.context.ticket_id ? ` ticket="${this.context.ticket_id}"` : "";
+    this.info(`START stage="${stageId}" agent="${agentId}" skill="${skillId}"${ticketInfo}`, stageId);
   }
 
   /**
@@ -1563,7 +1565,7 @@ class PipelineRunner {
         }
         throw err;
       }
-    }
+    }
 
     /**
      * Читает approval-файл и парсит его как JSON.
@@ -1586,7 +1588,7 @@ class PipelineRunner {
         // Перебрасываем другие ошибки (например, fs-ошибки) без изменений
         throw err;
       }
-    }
+    }
 
     /**
      * Выполняет встроенный стейдж типа update-counter:
@@ -1755,7 +1757,7 @@ class PipelineRunner {
         this.logger.warn(`[${stageId}] manual-gate: aborted (runner stopped)`, stageId);
       }
       return { status: 'aborted', result: { step_id: stepId } };
-    }
+    }
 
   /**
    * Запускает основной цикл выполнения
@@ -1801,7 +1803,7 @@ class PipelineRunner {
            this.currentExecutor = new StageExecutor(this.config, this.context, this.counters, {}, this.fileGuard, this.logger, this.projectRoot);
            result = await this.currentExecutor.execute(this.currentStage);
            this.currentExecutor = null;
-         }
+         }
 
         this.logger.info(`Stage ${this.currentStage} completed with status: ${result.status}`, 'PipelineRunner');
 
@@ -2145,18 +2147,40 @@ async function runPipeline(argv = process.argv.slice(2)) {
     return { exitCode: 0, help: true };
   }
 
-  // Resolve config path
+  // Resolve config path and projectRoot
   if (!args.config) {
     const projectRoot = args.project ? path.resolve(args.project) : findProjectRoot();
     args.config = path.resolve(projectRoot, '.workflow/config/pipeline.yaml');
+    args.projectRoot = projectRoot;
   }
 
+  const projectRoot = args.projectRoot || (args.project ? path.resolve(args.project) : findProjectRoot());
+
   console.log('=== Workflow Runner ===');
   console.log(`Config: ${args.config}`);
   if (args.plan) console.log(`Plan: ${args.plan}`);
   if (args.project) console.log(`Project: ${args.project}`);
   console.log('');
 
+  // Write marker to protect against stale processes
+  try {
+    writeMarker(projectRoot, {
+      pid: process.pid,
+      timestamp: new Date().toISOString()
+    });
+  } catch (err) {
+    console.error(`[runner] failed to write marker: ${err.message}`);
+    return { exitCode: 1, error: 'Failed to acquire pipeline lock', details: err.message };
+  }
+
+  // Register signal handlers for cleanup
+  const cleanup = () => {
+    removeMarker(projectRoot);
+    process.exit(130); // 128 + SIGINT(2) — standard exit code for signal-terminated
+  };
+  process.once('SIGINT', cleanup);
+  process.once('SIGTERM', cleanup);
+
   try {
     const config = loadConfig(args.config);
     const errors = validateConfig(config);
@@ -2191,6 +2215,16 @@ async function runPipeline(argv = process.argv.slice(2)) {
     await new Promise(resolve => setTimeout(resolve, 100));
 
     return { exitCode: 1, error: err.message, stack: err.stack };
+  } finally {
+    // Ensure marker is cleaned up on normal exit
+    try {
+      removeMarker(projectRoot);
+    } catch (err) {
+      // ENOENT is expected, log warnings for other errors
+      if (err.code && err.code !== 'ENOENT') {
+        console.warn(`[runner] cleanup warning: ${err.message}`);
+      }
+    }
   }
 }
 

package/src/scripts/check-relevance.js

@@ -100,10 +100,12 @@ function findTicketInColumns(ticketId) {
 
 async function checkRelevance(ticketPath) {
   if (!fs.existsSync(ticketPath)) {
+    // file_not_found — это не ошибка скрипта (verdict=relevant — fail-safe).
+    // Не выходим с exit=1, чтобы pipeline продолжил выполнение следующего стейджа.
     return {
       verdict: "relevant",
       reason: "file_not_found",
-      error: `Ticket file not found: ${ticketPath}`,
+      warning: `Ticket file not found: ${ticketPath}`,
     };
   }
 

package/src/scripts/get-next-id.js

@@ -85,7 +85,7 @@ function readPrefixesFromConfig() {
     throw new Error(`config.yaml not found: ${configPath}`);
   }
 
-  const text = fs.readFileSync(configPath, "utf8");
+  const text = fs.readFileSync(configPath, "utf8");
   const lines = text.split(/\r?\n/);
 
   const prefixes = [];

package/src/scripts/mark-blocked.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+/**
+ * mark-blocked.js - Скрипт для обновления frontmatter тикета и записи в alerts.jsonl
+ *
+ * Использование:
+ *   node mark-blocked.js <ticket_id> --attempts=N --reason=<str>
+ *
+ * Примеры:
+ *   node mark-blocked.js IMPL-59 --attempts=6 --reason=max_review_attempts
+ *   node mark-blocked.js QA-40 --attempts=3 --reason=human_gate_rejected
+ */
+
+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,
+  serializeFrontmatter,
+} from "workflow-ai/lib/utils.mjs";
+
+// Корень проекта
+const PROJECT_DIR = findProjectRoot();
+// Базовая директория workflow
+const WORKFLOW_DIR = path.join(PROJECT_DIR, ".workflow");
+const TICKETS_DIR = path.join(WORKFLOW_DIR, "tickets");
+// Директория state
+const STATE_DIR = path.join(PROJECT_DIR, ".workflow", "state");
+const ALERTS_FILE = path.join(STATE_DIR, "alerts.jsonl");
+
+// Парсинг аргументов
+const args = process.argv.slice(2);
+if (args.length < 3) {
+  console.error("Ошибка: недостаточно аргументов");
+  console.error("Использование: node mark-blocked.js <ticket_id> --attempts=N --reason=<str>");
+  process.exit(1);
+}
+
+const ticketId = args[0];
+let attempts = null;
+let reason = null;
+
+// Парсинг флагов
+for (let i = 1; i < args.length; i++) {
+  const arg = args[i];
+  if (arg.startsWith("--attempts=")) {
+    attempts = parseInt(arg.substring("--attempts=".length), 10);
+    if (isNaN(attempts)) {
+      console.error("Ошибка: некорректный формат --attempts");
+      process.exit(1);
+    }
+  } else if (arg.startsWith("--reason=")) {
+    reason = arg.substring("--reason=".length);
+  }
+}
+
+// Проверка обязательного параметра reason
+if (!reason) {
+  console.error("Ошибка: параметр --reason обязателен");
+  process.exit(1);
+}
+
+// Поиск файла тикета рекурсивно
+function findTicketFile(ticketId, searchDir) {
+  try {
+    const files = fs.readdirSync(searchDir, { withFileTypes: true });
+    
+    for (const file of files) {
+      const fullPath = path.join(searchDir, file.name);
+      
+      if (file.isDirectory()) {
+        // Рекурсивный поиск в поддиректориях
+        const found = findTicketFile(ticketId, fullPath);
+        if (found) return found;
+      } else if (file.isFile() && file.name.endsWith('.md') && file.name.startsWith(ticketId)) {
+        return fullPath;
+      }
+    }
+  } catch (error) {
+    console.error(`Ошибка при чтении директории ${searchDir}:`, error.message);
+  }
+  
+  return null;
+}
+
+// Основная функция
+function main() {
+  try {
+    // Поиск файла тикета
+    const ticketFile = findTicketFile(ticketId, TICKETS_DIR);
+    if (!ticketFile) {
+      console.error(`Ошибка: тикет ${ticketId} не найден в ${TICKETS_DIR}`);
+      process.exit(1);
+    }
+
+    // Чтение файла тикета
+    const content = fs.readFileSync(ticketFile, 'utf8');
+    const { frontmatter, body } = parseFrontmatter(content);
+
+    // Обновление frontmatter
+    const now = new Date().toISOString();
+    frontmatter.auto_blocked_reason = reason;
+    frontmatter.auto_blocked_attempts = attempts;
+    frontmatter.auto_blocked_at = now;
+
+    // Сериализация и запись обратно в файл
+    const newContent = serializeFrontmatter(frontmatter) + body;
+    fs.writeFileSync(ticketFile, newContent, 'utf8');
+
+    console.log(`✅ Frontmatter тикета ${ticketId} обновлен`);
+
+    // Попытка записи в alerts.jsonl
+    try {
+      // Создание директории state если не существует
+      if (!fs.existsSync(STATE_DIR)) {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        console.log(`✅ Директория ${STATE_DIR} создана`);
+      }
+
+      // Формирование JSONL записи
+      const alertEntry = {
+        timestamp: now,
+        severity: "warning",
+        kind: "ticket_auto_blocked",
+        project: path.basename(PROJECT_DIR),
+        ticket_id: ticketId,
+        attempts: attempts,
+        reason: reason,
+        stage: "review-result"
+      };
+
+      // Append-only запись в alerts.jsonl
+      fs.appendFileSync(ALERTS_FILE, JSON.stringify(alertEntry) + '\n', 'utf8');
+      console.log(`✅ Запись добавлена в ${ALERTS_FILE}`);
+
+    } catch (alertError) {
+      console.warn(`⚠️  Предупреждение: не удалось записать в alerts.jsonl: ${alertError.message}`);
+      console.log(`ℹ️  Frontmatter обновлен, запись в alerts пропущена`);
+    }
+
+    // Вывод результата
+    printResult({
+      ticket_id: ticketId,
+      reason: reason,
+      attempts: attempts,
+      blocked_at: now,
+      alerts_file: ALERTS_FILE,
+      status: "completed"
+    });
+
+  } catch (error) {
+    console.error(`Ошибка: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// Запуск скрипта
+main();