workflow-ai 1.0.61 → 1.0.63

package/src/scripts/check-plan-decomposed.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+/**
+ * check-plan-decomposed.js — Проверяет состояние декомпозиции планов.
+ *
+ * Логика:
+ *   A) Если plan_id задан — проверяет только этот план
+ *   B) Если plan_id НЕ задан — сканирует все планы в plans/current/
+ *
+ *   Для каждого плана в режиме B учитывается его status:
+ *   - draft / completed / archived → skip
+ *   - approved + нет тикетов → needs_decomposition (→ decompose-plan)
+ *   - approved + есть тикеты   → awaiting_atomicity (→ verify-atomicity):
+ *                                тикеты созданы, но атомарность не подтверждена
+ *                                (status плана ещё не активирован).
+ *   - active + есть тикеты    → decomposed (→ check-conditions)
+ *   - active + нет тикетов    → аномалия, logs warn, skip
+ *
+ *   Результат:
+ *   - needs_decomposition + plan_file — найден approved-план без тикетов
+ *   - awaiting_atomicity + plan_file  — найден approved-план с тикетами (ждёт verify-atomicity)
+ *   - decomposed                      — все активные планы имеют тикеты, штатный поток
+ *   - no_plan                         — нет планов в plans/current/
+ *
+ * Использование:
+ *   node check-plan-decomposed.js "plan_id: PLAN-007"
+ *   node check-plan-decomposed.js
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { findProjectRoot } from 'workflow-ai/lib/find-root.mjs';
+import { parseFrontmatter, printResult, normalizePlanId, extractPlanId } 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 PLANS_DIR = path.join(WORKFLOW_DIR, 'plans', 'current');
+
+const TICKET_DIRS = ['backlog', 'ready', 'in-progress', 'review', 'done', 'blocked'];
+
+/**
+ * Читает статус плана из frontmatter.
+ * Возвращает актуальный статус (draft / approved / active / completed / archived)
+ * или null при ошибке. Pipeline различает approved (ожидает декомпозиции или
+ * атомарности) и active (прошёл атомарность, в работе).
+ */
+function getPlanStatus(planFile) {
+  const fullPath = path.join(WORKFLOW_DIR, planFile);
+  if (!fs.existsSync(fullPath)) return null;
+  try {
+    const content = fs.readFileSync(fullPath, 'utf8');
+    const { frontmatter } = parseFrontmatter(content);
+    return frontmatter.status || null;
+  } catch (e) {
+    console.error(`[WARN] Failed to read plan status from ${planFile}: ${e.message}`);
+    return null;
+  }
+}
+
+/**
+ * Проверяет, есть ли тикеты, привязанные к данному плану
+ */
+function hasTicketsForPlan(planId) {
+  for (const dir of TICKET_DIRS) {
+    const dirPath = path.join(TICKETS_DIR, dir);
+    if (!fs.existsSync(dirPath)) continue;
+
+    const files = fs.readdirSync(dirPath)
+      .filter(f => f.endsWith('.md') && f !== '.gitkeep.md');
+
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(dirPath, file), 'utf8');
+        const { frontmatter } = parseFrontmatter(content);
+        if (normalizePlanId(frontmatter.parent_plan) === planId) {
+          return true;
+        }
+      } catch (e) {
+        console.error(`[WARN] Failed to read ${dir}/${file}: ${e.message}`);
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Находит файл плана в plans/current/
+ */
+function findPlanFile(planId) {
+  if (!fs.existsSync(PLANS_DIR)) return null;
+
+  const expectedName = `${planId}.md`;
+  const filePath = path.join(PLANS_DIR, expectedName);
+  if (fs.existsSync(filePath)) {
+    return `plans/current/${expectedName}`;
+  }
+
+  // Поиск по всем файлам на случай другого именования
+  const files = fs.readdirSync(PLANS_DIR).filter(f => f.endsWith('.md'));
+  for (const file of files) {
+    if (normalizePlanId(file) === planId) {
+      return `plans/current/${file}`;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Возвращает все файлы планов из plans/current/
+ */
+function getAllPlanFiles() {
+  if (!fs.existsSync(PLANS_DIR)) return [];
+
+  return fs.readdirSync(PLANS_DIR)
+    .filter(f => f.endsWith('.md'))
+    .map(f => ({
+      planId: normalizePlanId(f),
+      planFile: `plans/current/${f}`
+    }))
+    .filter(p => p.planId !== null);
+}
+
+async function main() {
+  const planId = extractPlanId();
+
+  if (planId) {
+    // Режим A: конкретный план
+    console.log(`[INFO] Checking decomposition for plan: ${planId}`);
+
+    const planFile = findPlanFile(planId);
+    if (!planFile) {
+      console.log(`[INFO] Plan ${planId} not found in plans/current/`);
+      printResult({ status: 'no_plan' });
+      return;
+    }
+
+    console.log(`[INFO] Found plan file: ${planFile}`);
+
+    const planStatus = getPlanStatus(planFile);
+    const hasTickets = hasTicketsForPlan(planId);
+
+    if (hasTickets && planStatus === 'active') {
+      console.log(`[INFO] Plan ${planId} is active and has tickets — decomposed`);
+      printResult({ status: 'decomposed' });
+      return;
+    }
+
+    if (hasTickets && planStatus === 'approved') {
+      console.log(`[INFO] Plan ${planId} is approved and has tickets — awaiting atomicity verification`);
+      printResult({ status: 'awaiting_atomicity', plan_file: planFile });
+      return;
+    }
+
+    if (!hasTickets) {
+      console.log(`[INFO] Plan ${planId} has no tickets — needs decomposition`);
+      printResult({ status: 'needs_decomposition', plan_file: planFile });
+      return;
+    }
+
+    console.log(`[INFO] Plan ${planId} has tickets but status="${planStatus}" — treating as decomposed`);
+    printResult({ status: 'decomposed' });
+    return;
+  }
+
+  // Режим B: сканируем все планы в plans/current/
+  console.log('[INFO] No plan_id specified, scanning all plans in plans/current/');
+
+  const allPlans = getAllPlanFiles();
+  if (allPlans.length === 0) {
+    console.log('[INFO] No plans found in plans/current/');
+    printResult({ status: 'no_plan' });
+    return;
+  }
+
+  console.log(`[INFO] Found ${allPlans.length} plan(s) in plans/current/`);
+
+  for (const { planId: pid, planFile } of allPlans) {
+    const planStatus = getPlanStatus(planFile);
+
+    if (planStatus !== 'approved' && planStatus !== 'active') {
+      console.log(`[INFO] Plan ${pid} has status "${planStatus}" — skipping`);
+      continue;
+    }
+
+    const hasTickets = hasTicketsForPlan(pid);
+
+    if (planStatus === 'approved' && !hasTickets) {
+      console.log(`[INFO] Plan ${pid} is approved with no tickets — needs decomposition`);
+      printResult({ status: 'needs_decomposition', plan_file: planFile });
+      return;
+    }
+
+    if (planStatus === 'approved' && hasTickets) {
+      console.log(`[INFO] Plan ${pid} is approved and has tickets — awaiting atomicity verification`);
+      printResult({ status: 'awaiting_atomicity', plan_file: planFile });
+      return;
+    }
+
+    if (planStatus === 'active' && !hasTickets) {
+      console.log(`[WARN] Plan ${pid} is active but has no tickets — anomaly, skipping`);
+      continue;
+    }
+
+    console.log(`[INFO] Plan ${pid} is active and has tickets — decomposed`);
+  }
+
+  console.log('[INFO] All eligible plans are decomposed');
+  printResult({ status: 'decomposed' });
+}
+
+main().catch(e => {
+  console.error(`[ERROR] ${e.message}`);
+  printResult({ status: 'error', error: e.message });
+  process.exit(1);
+});

package/src/scripts/check-plan-templates.js

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+
+/**
+ * check-plan-templates.js — Проверяет шаблоны планов и создаёт планы по триггерам.
+ *
+ * Логика:
+ *   1. Читает все .md из plans/templates/
+ *   2. Для каждого с enabled: true — проверяет триггер
+ *   3. Если триггер сработал — создаёт план в plans/current/ со статусом approved
+ *   4. Обновляет last_triggered в шаблоне
+ *
+ * Типы триггеров:
+ *   - daily          — раз в день
+ *   - weekly         — в указанные дни недели (params.days_of_week: [0-6])
+ *   - date_after     — однократно после указанной даты (params.date)
+ *   - interval_days  — каждые N дней (params.days)
+ *
+ * Результат:
+ *   - plan_created + plan_ids — созданы планы
+ *   - no_triggers — ни один триггер не сработал
+ *   - error — ошибка
+ *
+ * Использование:
+ *   node check-plan-templates.js
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { findProjectRoot } from 'workflow-ai/lib/find-root.mjs';
+import { parseFrontmatter, serializeFrontmatter, printResult } from 'workflow-ai/lib/utils.mjs';
+
+const PROJECT_DIR = findProjectRoot();
+const WORKFLOW_DIR = path.join(PROJECT_DIR, '.workflow');
+const TEMPLATES_DIR = path.join(WORKFLOW_DIR, 'plans', 'templates');
+const PLANS_DIR = path.join(WORKFLOW_DIR, 'plans', 'current');
+const TICKETS_DIR = path.join(WORKFLOW_DIR, 'tickets');
+const DONE_DIR = 'done';
+
+/**
+ * Проверяет, сработал ли триггер шаблона.
+ *
+ * @param {{ type: string, params?: object }} trigger — конфигурация триггера
+ * @param {string} lastTriggered — ISO-дата последнего срабатывания (или пустая строка)
+ * @param {Date} [now] — текущая дата (для тестов)
+ * @returns {boolean}
+ */
+export function evaluateTrigger(trigger, lastTriggered, now = new Date()) {
+  if (!trigger || !trigger.type) return false;
+
+  const todayStr = now.toISOString().slice(0, 10);
+  const lastDate = lastTriggered ? String(lastTriggered).slice(0, 10) : null;
+
+  switch (trigger.type) {
+    case 'daily':
+      return lastDate !== todayStr;
+
+    case 'weekly': {
+      const dayOfWeek = now.getDay();
+      const targetDays = trigger.params?.days_of_week || [1];
+      if (!targetDays.includes(dayOfWeek)) return false;
+      return lastDate !== todayStr;
+    }
+
+    case 'date_after': {
+      const targetDate = trigger.params?.date;
+      if (!targetDate) return false;
+      if (todayStr < targetDate) return false;
+      return !lastDate || lastDate < targetDate;
+    }
+
+    case 'interval_days': {
+      const intervalDays = trigger.params?.days || 1;
+      if (!lastDate) return true;
+      const lastTime = new Date(lastDate).getTime();
+      const elapsed = (now.getTime() - lastTime) / (1000 * 60 * 60 * 24);
+      return elapsed >= intervalDays;
+    }
+
+    default:
+      console.error(`[WARN] Unknown trigger type: ${trigger.type}`);
+      return false;
+  }
+}
+
+/**
+ * Генерирует следующий ID плана (PLAN-NNN), сканируя plans/current/.
+ *
+ * @param {string} plansDir — путь к директории plans/current/
+ * @returns {string}
+ */
+export function generateNextPlanId(plansDir) {
+  const archiveDir = path.join(path.dirname(plansDir), 'archive');
+  let maxNum = 0;
+
+  for (const dir of [plansDir, archiveDir]) {
+    if (!fs.existsSync(dir)) continue;
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+    for (const file of files) {
+      const match = file.match(/^PLAN-(\d+)\.md$/i);
+      if (match) {
+        const num = parseInt(match[1], 10);
+        if (num > maxNum) maxNum = num;
+      }
+    }
+  }
+
+  return `PLAN-${String(maxNum + 1).padStart(3, '0')}`;
+}
+
+/**
+ * Создаёт план из шаблона.
+ *
+ * @param {string} templatePath — полный путь к файлу шаблона
+ * @param {object} templateFm — frontmatter шаблона
+ * @param {string} templateBody — тело шаблона
+ * @param {string} planId — ID нового плана
+ * @param {string} todayStr — сегодняшняя дата ISO
+ * @returns {string} путь к созданному плану
+ */
+function createPlanFromTemplate(templatePath, templateFm, templateBody, planId, todayStr) {
+  const planFm = {
+    id: planId,
+    title: `${templateFm.title} (${todayStr})`,
+    status: 'approved',
+    source_template: templateFm.id,
+    author: templateFm.author || 'system',
+    created_at: todayStr,
+    updated_at: todayStr,
+    completed_at: '',
+    previous_plan: '',
+    related_reports: []
+  };
+
+  const planContent = serializeFrontmatter(planFm) + '\n' + templateBody;
+  const planFileName = `${planId}.md`;
+  const planPath = path.join(PLANS_DIR, planFileName);
+
+  if (!fs.existsSync(PLANS_DIR)) {
+    fs.mkdirSync(PLANS_DIR, { recursive: true });
+  }
+
+  fs.writeFileSync(planPath, planContent, 'utf8');
+  console.log(`[INFO] Created plan ${planId} from template ${templateFm.id}`);
+
+  return planPath;
+}
+
+/**
+ * Обновляет last_triggered в шаблоне.
+ *
+ * @param {string} templatePath — полный путь к файлу шаблона
+ * @param {object} frontmatter — frontmatter шаблона
+ * @param {string} body — тело шаблона
+ * @param {string} todayStr — сегодняшняя дата ISO
+ */
+function updateTemplateLastTriggered(templatePath, frontmatter, body, todayStr) {
+  frontmatter.last_triggered = todayStr;
+  const content = serializeFrontmatter(frontmatter) + '\n' + body;
+  fs.writeFileSync(templatePath, content, 'utf8');
+  console.log(`[INFO] Updated last_triggered for ${frontmatter.id} to ${todayStr}`);
+}
+
+/**
+ * Проверяет, есть ли незавершённые тикеты по планам, созданным из данного шаблона.
+ * Тикет считается незавершённым, если он находится не в done/.
+ *
+ * @param {string} templateId — ID шаблона (например, "TMPL-001")
+ * @returns {boolean} true если есть активные тикеты
+ */
+export function hasActiveTicketsForTemplate(templateId) {
+  // 1. Найти все планы с source_template === templateId
+  const planPaths = [];
+  if (fs.existsSync(PLANS_DIR)) {
+    for (const file of fs.readdirSync(PLANS_DIR).filter(f => f.endsWith('.md'))) {
+      const content = fs.readFileSync(path.join(PLANS_DIR, file), 'utf8');
+      const { frontmatter } = parseFrontmatter(content);
+      if (frontmatter.source_template === templateId) {
+        planPaths.push(`plans/current/${file}`);
+      }
+    }
+  }
+
+  if (planPaths.length === 0) return false;
+
+  // 2. Проверить тикеты во всех папках кроме done/
+  if (!fs.existsSync(TICKETS_DIR)) return false;
+
+  const ticketDirs = fs.readdirSync(TICKETS_DIR, { withFileTypes: true })
+    .filter(d => d.isDirectory() && d.name !== DONE_DIR)
+    .map(d => d.name);
+
+  for (const dir of ticketDirs) {
+    const dirPath = path.join(TICKETS_DIR, dir);
+    const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.md'));
+
+    for (const file of files) {
+      const content = fs.readFileSync(path.join(dirPath, file), 'utf8');
+      const { frontmatter } = parseFrontmatter(content);
+      if (frontmatter.parent_plan && planPaths.includes(frontmatter.parent_plan)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+async function main() {
+  if (!fs.existsSync(TEMPLATES_DIR)) {
+    console.log('[INFO] Templates directory does not exist, nothing to check');
+    printResult({ status: 'no_triggers' });
+    return;
+  }
+
+  const templateFiles = fs.readdirSync(TEMPLATES_DIR)
+    .filter(f => f.endsWith('.md'));
+
+  if (templateFiles.length === 0) {
+    console.log('[INFO] No template files found');
+    printResult({ status: 'no_triggers' });
+    return;
+  }
+
+  console.log(`[INFO] Found ${templateFiles.length} template(s) in plans/templates/`);
+
+  const now = new Date();
+  const todayStr = now.toISOString().slice(0, 10);
+  const createdPlanIds = [];
+
+  for (const file of templateFiles) {
+    const templatePath = path.join(TEMPLATES_DIR, file);
+
+    try {
+      const content = fs.readFileSync(templatePath, 'utf8');
+      const { frontmatter, body } = parseFrontmatter(content);
+
+      if (frontmatter.type !== 'template') {
+        console.log(`[INFO] Skipping ${file} — type is not "template"`);
+        continue;
+      }
+
+      if (!frontmatter.enabled) {
+        console.log(`[INFO] Skipping ${file} — disabled`);
+        continue;
+      }
+
+      if (!frontmatter.trigger) {
+        console.log(`[WARN] Skipping ${file} — no trigger defined`);
+        continue;
+      }
+
+      const shouldTrigger = evaluateTrigger(frontmatter.trigger, frontmatter.last_triggered, now);
+
+      if (!shouldTrigger) {
+        console.log(`[INFO] Template ${frontmatter.id}: trigger not fired`);
+        continue;
+      }
+
+      console.log(`[INFO] Template ${frontmatter.id}: trigger fired!`);
+
+      if (hasActiveTicketsForTemplate(frontmatter.id)) {
+        console.log(`[INFO] Template ${frontmatter.id}: skipped — active tickets exist from previous plan`);
+        continue;
+      }
+
+      const planId = generateNextPlanId(PLANS_DIR);
+      createPlanFromTemplate(templatePath, frontmatter, body, planId, todayStr);
+      updateTemplateLastTriggered(templatePath, frontmatter, body, todayStr);
+      createdPlanIds.push(planId);
+
+    } catch (e) {
+      console.error(`[WARN] Failed to process template ${file}: ${e.message}`);
+    }
+  }
+
+  if (createdPlanIds.length > 0) {
+    console.log(`[INFO] Created ${createdPlanIds.length} plan(s): ${createdPlanIds.join(', ')}`);
+    printResult({ status: 'plan_created', plan_ids: createdPlanIds.join(', ') });
+  } else {
+    console.log('[INFO] No triggers fired');
+    printResult({ status: 'no_triggers' });
+  }
+}
+
+// Запуск main() только при прямом вызове (не при импорте)
+const isDirectRun = process.argv[1] && (
+  process.argv[1].endsWith('check-plan-templates.js') ||
+  process.argv[1].endsWith('check-plan-templates')
+);
+
+if (isDirectRun) {
+  main().catch(e => {
+    console.error(`[ERROR] ${e.message}`);
+    printResult({ status: 'error', error: e.message });
+    process.exit(1);
+  });
+}