workflow-ai 1.0.61 → 1.0.63

package/src/scripts/check-relevance.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+
+/**
+ * check-relevance.js - Скрипт проверки актуальности тикета
+ *
+ * Использование:
+ *   node check-relevance.js <path-to-ticket>
+ *
+ * Вывод:
+ *   ---RESULT---
+ *   verdict: relevant|irrelevant
+ *   reason: ...
+ *   ---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,
+  serializeFrontmatter,
+  getLastReviewStatus,
+} 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 VALID_STATUSES = [
+  "backlog",
+  "ready",
+  "in-progress",
+  "blocked",
+  "review",
+  "done",
+  "archive",
+];
+
+function getCurrentStatus(ticketPath) {
+  const fileName = path.basename(ticketPath);
+  for (const status of VALID_STATUSES) {
+    const statusDir = path.join(TICKETS_DIR, status);
+    const expectedPath = path.join(statusDir, fileName);
+    if (ticketPath === expectedPath) {
+      return status;
+    }
+  }
+  return null;
+}
+
+function extractPlanId(parentPlan) {
+  if (!parentPlan) return null;
+  const basename = path.basename(parentPlan, ".md");
+  const match = basename.match(/^PLAN-(\d+)$/i);
+  if (match) {
+    return `PLAN-${String(parseInt(match[1], 10)).padStart(3, "0")}`;
+  }
+  return basename;
+}
+
+function getDodCompletion(content) {
+  const dodSectionMatch = content.match(/## Критерии готовности.*?\n([\s\S]*?)(?=\n## |\n# |\z)/i);
+  if (!dodSectionMatch) return { completed: false, total: 0, checked: 0 };
+
+  const section = dodSectionMatch[1];
+  const checkedMatches = section.match(/\[x\]/gi) || [];
+  const uncheckedMatches = section.match(/\[ \]/gi) || [];
+
+  const total = checkedMatches.length + uncheckedMatches.length;
+  const completed = total > 0 && uncheckedMatches.length === 0;
+
+  return { completed, total, checked: checkedMatches.length };
+}
+
+function hasResultSection(content) {
+  const resultPatterns = [
+    /##\s*Result/gi,
+    /##\s*Результат/gi,
+    /##\s*Результат выполнения/gi,
+  ];
+  return resultPatterns.some((pattern) => pattern.test(content));
+}
+
+function getBlockedSection(content) {
+  const blockedMatch = content.match(/##\s*Блокировки\s*\n([\s\S]*?)(?=\n## |\n# |\z)/i);
+  return blockedMatch ? blockedMatch[1].trim() : "";
+}
+
+function findTicketInColumns(ticketId) {
+  for (const status of VALID_STATUSES) {
+    const statusDir = path.join(TICKETS_DIR, status);
+    const ticketPath = path.join(statusDir, `${ticketId}.md`);
+    if (fs.existsSync(ticketPath)) {
+      return status;
+    }
+  }
+  return null;
+}
+
+async function checkRelevance(ticketPath) {
+  if (!fs.existsSync(ticketPath)) {
+    return {
+      verdict: "relevant",
+      reason: "file_not_found",
+      error: `Ticket file not found: ${ticketPath}`,
+    };
+  }
+
+  let content;
+  try {
+    content = fs.readFileSync(ticketPath, "utf8");
+  } catch (e) {
+    return {
+      verdict: "relevant",
+      reason: "read_error",
+      error: `Failed to read ticket: ${e.message}`,
+    };
+  }
+
+  let frontmatter, body;
+  try {
+    ({ frontmatter, body } = parseFrontmatter(content));
+  } catch (e) {
+    return {
+      verdict: "relevant",
+      reason: "invalid_frontmatter",
+      warning: `Failed to parse frontmatter: ${e.message}. Treating as relevant (fail-safe).`,
+    };
+  }
+
+  const currentStatus = getCurrentStatus(ticketPath);
+  const fullContent = body;
+
+  const lastReview = getLastReviewStatus(fullContent);
+  if (lastReview === "skipped") {
+    return { verdict: "irrelevant", reason: "already_skipped" };
+  }
+  if (lastReview === "failed") {
+    return { verdict: "relevant", reason: "review_failed_needs_rework" };
+  }
+
+  if (frontmatter.blocked === true || frontmatter.blocked === "true") {
+    return { verdict: "relevant", reason: "blocked" };
+  }
+
+  const blockedSection = getBlockedSection(fullContent);
+  const hasActiveBlockers = blockedSection.length > 0 && !blockedSection.includes("нет");
+  if (hasActiveBlockers) {
+    return { verdict: "relevant", reason: "blocked" };
+  }
+
+  const parentPlan = frontmatter.parent_plan;
+  if (parentPlan) {
+    const planId = extractPlanId(parentPlan);
+    if (planId) {
+      const planPath = path.join(WORKFLOW_DIR, "plans", "current", `${planId}.md`);
+      if (fs.existsSync(planPath)) {
+        try {
+          const planContent = fs.readFileSync(planPath, "utf8");
+          const { frontmatter: planFm } = parseFrontmatter(planContent);
+          const planStatus = planFm.status;
+          if (["completed", "archived", "cancelled"].includes(planStatus)) {
+            return { verdict: "irrelevant", reason: "plan_inactive" };
+          }
+        } catch (e) {
+          // fail-safe: treat as relevant
+        }
+      } else {
+        // fail-safe: treat as relevant
+      }
+    }
+  } else {
+    // fail-safe: parent_plan is empty
+  }
+
+  const dod = getDodCompletion(fullContent);
+  const hasResult = hasResultSection(fullContent);
+
+  if (dod.completed && hasResult) {
+    if (lastReview === "passed") {
+      return { verdict: "irrelevant", reason: "dod_completed" };
+    } else if (lastReview === null) {
+      return { verdict: "relevant", reason: "needs_review" };
+    }
+  }
+
+  const dependencies = frontmatter.dependencies || [];
+  if (dependencies.length > 0) {
+    for (const dep of dependencies) {
+      const depStatus = findTicketInColumns(dep);
+      if (depStatus === null) {
+        return { verdict: "irrelevant", reason: "dependencies_inactive" };
+      }
+      if (depStatus === "blocked") {
+        try {
+          const blockedDir = path.join(TICKETS_DIR, "blocked", `${dep}.md`);
+          const blockedContent = fs.readFileSync(blockedDir, "utf8");
+          const { body: blockedBody } = parseFrontmatter(blockedContent);
+          if (blockedBody.toLowerCase().includes("неактуально")) {
+            return { verdict: "irrelevant", reason: "dependencies_inactive" };
+          }
+        } catch (e) {
+          // ignore
+        }
+      }
+    }
+  }
+
+  return { verdict: "relevant", reason: "all_checks_passed" };
+}
+
+function addSkippedReview(ticketPath, reason) {
+  const now = new Date();
+  const date = now.toISOString().slice(0, 10);
+
+  let content;
+  try {
+    content = fs.readFileSync(ticketPath, "utf8");
+  } catch (e) {
+    throw new Error(`Failed to read ticket: ${e.message}`);
+  }
+
+  let { frontmatter, body } = parseFrontmatter(content);
+
+  const reviewSectionMatch = body.match(/##\s*Ревью\s*\n([\s\S]*)/i);
+  let newBody;
+
+  if (reviewSectionMatch) {
+    const reviewContent = reviewSectionMatch[1];
+    const lines = reviewContent.split("\n");
+    let insertIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].trim().startsWith("|") && lines[i].includes("---")) {
+        insertIndex = i + 1;
+        break;
+      }
+    }
+
+    const newRow = `| ${date} | ⏭️ skipped | ${reason} |`;
+    lines.splice(insertIndex, 0, newRow);
+    newBody = body.slice(0, reviewSectionMatch.index) + lines.join("\n");
+  } else {
+    const reviewTable = `\n## Ревью\n\n| Дата | Статус | Самари |\n|------|--------|--------|\n| ${date} | ⏭️ skipped | ${reason} |\n`;
+    newBody = body.trimEnd() + reviewTable;
+  }
+
+  const newContent = serializeFrontmatter(frontmatter) + newBody;
+  fs.writeFileSync(ticketPath, newContent, "utf8");
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  let ticketPath;
+
+  if (args.length === 0) {
+    console.error("Usage: node check-relevance.js <path-to-ticket>");
+    console.error("Example: node check-relevance.js .workflow/tickets/in-progress/IMPL-001.md");
+    process.exit(1);
+  } else if (args.length === 1) {
+    const arg = args[0];
+    const ticketMatch = arg.match(/ticket_id:\s*(\S+)/);
+    if (ticketMatch) {
+      const ticketId = ticketMatch[1];
+      ticketPath = path.join(TICKETS_DIR, "in-progress", `${ticketId}.md`);
+    } else if (/^[A-Z]+-\d+$/i.test(arg)) {
+      // Чистый ticket_id (например, IMPL-001) — резолвим в in-progress
+      ticketPath = path.join(TICKETS_DIR, "in-progress", `${arg}.md`);
+    } else {
+      ticketPath = arg;
+    }
+  } else {
+    ticketPath = args[0];
+  }
+
+  if (!path.isAbsolute(ticketPath)) {
+    ticketPath = path.resolve(process.cwd(), ticketPath);
+  }
+
+  const result = await checkRelevance(ticketPath);
+
+  if (result.warning && !result.error) {
+    console.error(`[WARNING] ${result.warning}`);
+  }
+
+  if (result.error) {
+    console.error(`[ERROR] ${result.error}`);
+  }
+
+  if (result.verdict === "irrelevant") {
+    try {
+      addSkippedReview(ticketPath, result.reason);
+    } catch (e) {
+      console.error(`[ERROR] Failed to add review entry: ${e.message}`);
+    }
+  }
+
+  console.log("---RESULT---");
+  console.log(`verdict: ${result.verdict}`);
+  console.log(`reason: ${result.reason}`);
+  console.log("---RESULT---");
+
+  if (result.error) {
+    process.exit(1);
+  }
+}
+
+main().catch((e) => {
+  console.error("[FATAL]", e.message);
+  process.exit(1);
+});

package/src/scripts/complete-plan.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+
+/**
+ * complete-plan.js — Завершает план (status: completed) и архивирует тикеты.
+ *
+ * Логика:
+ *   1. Если plan_id задан в контексте — используем его
+ *   2. Если plan_id пуст — ищем единственный активный план в plans/current/
+ *   3. Вызываем checkAndClosePlan: проверяет, все ли тикеты в done/archive,
+ *      обновляет status → completed, архивирует done-тикеты
+ *
+ * Результаты:
+ *   - status: completed  — план успешно закрыт
+ *   - status: not_ready  — не все тикеты завершены
+ *   - status: no_plan    — план не найден
+ *   - status: error      — ошибка
+ *
+ * Использование:
+ *   node complete-plan.js "plan_id: PLAN-009"
+ *   node complete-plan.js PLAN-009
+ *   node complete-plan.js   (найдёт единственный активный план)
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { findProjectRoot } from 'workflow-ai/lib/find-root.mjs';
+import { parseFrontmatter, printResult, normalizePlanId, extractPlanId, checkAndClosePlan } from 'workflow-ai/lib/utils.mjs';
+
+const PROJECT_DIR = findProjectRoot();
+const WORKFLOW_DIR = path.join(PROJECT_DIR, '.workflow');
+const PLANS_DIR = path.join(WORKFLOW_DIR, 'plans', 'current');
+
+/**
+ * Находит активный план в plans/current/ (status: active).
+ * Возвращает planId или null.
+ */
+function findActivePlan() {
+  if (!fs.existsSync(PLANS_DIR)) return null;
+
+  const files = fs.readdirSync(PLANS_DIR).filter(f => f.endsWith('.md'));
+
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.join(PLANS_DIR, file), 'utf8');
+      const { frontmatter } = parseFrontmatter(content);
+      if (frontmatter.status === 'active') {
+        const planId = normalizePlanId(file);
+        if (planId) {
+          console.log(`[INFO] Found active plan: ${planId} (${file})`);
+          return planId;
+        }
+      }
+    } catch (_) { /* skip malformed */ }
+  }
+
+  return null;
+}
+
+// Main entry point
+const rawArgs = process.argv.slice(2);
+let planId = null;
+
+if (rawArgs.length >= 1) {
+  const arg = rawArgs[0];
+  const planMatch = arg.match(/plan_id:\s*(\S+)/i);
+  planId = planMatch ? normalizePlanId(planMatch[1]) : normalizePlanId(arg);
+}
+
+if (!planId) {
+  planId = extractPlanId();
+}
+
+if (!planId) {
+  console.log('[INFO] No plan_id in context, searching for active plan...');
+  planId = findActivePlan();
+}
+
+if (!planId) {
+  console.log('[INFO] No active plan found');
+  printResult({ status: 'no_plan' });
+  process.exit(0);
+}
+
+console.log(`[INFO] Completing plan: ${planId}`);
+
+const result = checkAndClosePlan(WORKFLOW_DIR, planId);
+
+if (result.closed) {
+  console.log(`[INFO] Plan ${planId} completed: ${result.done}/${result.total} tickets done, ${result.archived?.length || 0} archived`);
+  printResult({
+    status: 'completed',
+    plan_id: planId,
+    total: result.total,
+    done: result.done,
+    archived: result.archived?.length || 0
+  });
+} else {
+  console.log(`[INFO] Plan ${planId} not closed: ${result.reason}`);
+  printResult({
+    status: 'not_ready',
+    plan_id: planId,
+    reason: result.reason,
+    total: result.total,
+    done: result.done
+  });
+}

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

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+/**
+ * get-next-id.js - Универсальный генератор ID для тикетов, планов и других артефактов
+ *
+ * Режимы:
+ *
+ *   1) Одиночный префикс (legacy, для create-plan / create-report):
+ *      node get-next-id.js --prefix TASK --dir tickets
+ *      node get-next-id.js --prefix PLAN --dir plans
+ *      Вывод: { status: "success", id: "TASK-007" }
+ *
+ *   2) Карта по всем префиксам из config.yaml (для decompose-plan):
+ *      node get-next-id.js --all-from-config
+ *      Читает .workflow/config/config.yaml → task_types.*.prefix,
+ *      для каждого префикса возвращает следующий свободный номер по .workflow/tickets/.
+ *      Вывод: { status: "success", id_ranges: { TASK: 8, QA: 26, HUMAN: 2, ... } }
+ */
+
+import fs from "fs";
+import path from "path";
+import { findProjectRoot } from "workflow-ai/lib/find-root.mjs";
+import { printResult } from "workflow-ai/lib/utils.mjs";
+
+const PROJECT_DIR = findProjectRoot();
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let prefix = null;
+  let dir = null;
+  let allFromConfig = false;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--prefix" && i + 1 < args.length) {
+      prefix = args[i + 1];
+      i++;
+    } else if (args[i] === "--dir" && i + 1 < args.length) {
+      dir = args[i + 1];
+      i++;
+    } else if (args[i] === "--all-from-config") {
+      allFromConfig = true;
+    }
+  }
+
+  return { prefix, dir, allFromConfig };
+}
+
+function findMaxNumber(targetDir, prefix) {
+  let maxNum = 0;
+  const regex = new RegExp(`^${prefix}-(\\d+)\\.md$`, "i");
+
+  function scanDirectory(dir) {
+    if (!fs.existsSync(dir)) {
+      return;
+    }
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        scanDirectory(fullPath);
+      } else if (entry.isFile()) {
+        const match = entry.name.match(regex);
+        if (match) {
+          const num = parseInt(match[1], 10);
+          if (num > maxNum) {
+            maxNum = num;
+          }
+        }
+      }
+    }
+  }
+
+  scanDirectory(targetDir);
+  return maxNum;
+}
+
+function formatNumber(num) {
+  return num.toString().padStart(3, "0");
+}
+
+/**
+ * Извлекает значения prefix из .workflow/config/config.yaml → task_types.*.prefix.
+ * Минимальный YAML-парсер: не тянем зависимость, читаем только нужную секцию.
+ * Возвращает массив уникальных префиксов в порядке появления.
+ */
+function readPrefixesFromConfig() {
+  const configPath = path.join(PROJECT_DIR, ".workflow", "config", "config.yaml");
+
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`config.yaml not found: ${configPath}`);
+  }
+
+  const text = fs.readFileSync(configPath, "utf8");
+  const lines = text.split(/\r?\n/);
+
+  const prefixes = [];
+  let inTaskTypes = false;
+  let taskTypesIndent = -1;
+
+  for (const rawLine of lines) {
+    // Убрать комментарии
+    const line = rawLine.replace(/\s+#.*$/, "").replace(/^#.*$/, "");
+    if (line.trim() === "") continue;
+
+    const indent = line.length - line.trimStart().length;
+
+    if (!inTaskTypes) {
+      if (/^task_types\s*:\s*$/.test(line.trim())) {
+        inTaskTypes = true;
+        taskTypesIndent = indent;
+      }
+      continue;
+    }
+
+    // Вышли из секции task_types (вернулись на тот же или меньший отступ с новым ключом)
+    if (indent <= taskTypesIndent && line.trim() !== "") {
+      break;
+    }
+
+    const m = line.match(/^\s*prefix\s*:\s*["']?([A-Z][A-Z0-9_]*)["']?\s*$/);
+    if (m) {
+      const p = m[1];
+      if (!prefixes.includes(p)) {
+        prefixes.push(p);
+      }
+    }
+  }
+
+  if (prefixes.length === 0) {
+    throw new Error("No prefixes found in config.yaml → task_types.*.prefix");
+  }
+
+  return prefixes;
+}
+
+function resolveTargetDir(dir) {
+  if (dir === "tickets") {
+    return path.join(PROJECT_DIR, ".workflow", "tickets");
+  } else if (dir === "plans") {
+    return path.join(PROJECT_DIR, ".workflow", "plans");
+  } else {
+    return path.join(PROJECT_DIR, dir);
+  }
+}
+
+async function runSinglePrefix(prefix, dir) {
+  const targetDir = resolveTargetDir(dir);
+
+  if (!fs.existsSync(targetDir)) {
+    const nextId = `${prefix}-001`;
+    printResult({ status: "success", id: nextId });
+    return;
+  }
+
+  const maxNum = findMaxNumber(targetDir, prefix);
+  const nextNum = maxNum + 1;
+  const nextId = `${prefix}-${formatNumber(nextNum)}`;
+
+  printResult({ status: "success", id: nextId });
+}
+
+async function runAllFromConfig() {
+  const prefixes = readPrefixesFromConfig();
+  const ticketsDir = path.join(PROJECT_DIR, ".workflow", "tickets");
+
+  const idRanges = {};
+  for (const prefix of prefixes) {
+    const maxNum = fs.existsSync(ticketsDir) ? findMaxNumber(ticketsDir, prefix) : 0;
+    idRanges[prefix] = maxNum + 1;
+  }
+
+  // Параллельно возвращаем JSON-строку, потому что runner workflow-ai
+  // при подстановке $context.<key> в строку instructions применяет неявный
+  // toString() — объекты превращаются в "[object Object]". Скалярная
+  // JSON-строка подставляется корректно, декомпозитор распарсит её сам.
+  printResult({
+    status: "success",
+    id_ranges: idRanges,
+    id_ranges_json: JSON.stringify(idRanges),
+  });
+}
+
+async function main() {
+  const { prefix, dir, allFromConfig } = parseArgs();
+
+  if (allFromConfig) {
+    try {
+      await runAllFromConfig();
+    } catch (err) {
+      console.error(err.message);
+      printResult({ status: "error", error: err.message });
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (!prefix || !dir) {
+    console.error("Usage:");
+    console.error("  node get-next-id.js --prefix <PREFIX> --dir <DIRECTORY>");
+    console.error("  node get-next-id.js --all-from-config");
+    printResult({
+      status: "error",
+      error: "Missing required arguments: either --all-from-config, or both --prefix and --dir",
+    });
+    process.exit(1);
+  }
+
+  await runSinglePrefix(prefix, dir);
+}
+
+main();