workflow-ai 1.0.68 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workflow-ai",
-  "version": "1.0.68",
+  "version": "1.1.0",
   "description": "AI Agent Workflow Coordinator — kanban-based pipeline for AI coding agents",
   "type": "module",
   "bin": {
@@ -21,12 +21,15 @@
     "configs/",
     "agent-templates/"
   ],
-  "exports": {
-    "./lib/find-root.mjs": "./src/lib/find-root.mjs",
-    "./lib/utils.mjs": "./src/lib/utils.mjs",
-    "./lib/logger.mjs": "./src/lib/logger.mjs",
-    "./lib/js-yaml.mjs": "./src/lib/js-yaml.mjs"
-  },
+   "exports": {
+     "./lib/find-root.mjs": "./src/lib/find-root.mjs",
+     "./lib/utils.mjs": "./src/lib/utils.mjs",
+     "./lib/logger.mjs": "./src/lib/logger.mjs",
+     "./lib/js-yaml.mjs": "./src/lib/js-yaml.mjs",
+     "./lib/operations/tickets.mjs": "./src/lib/operations/tickets.mjs",
+     "./lib/operations/plans.mjs": "./src/lib/operations/plans.mjs",
+     "./lib/operations/skills.mjs": "./src/lib/operations/skills.mjs"
+   },
   "engines": {
     "node": ">=18.0.0"
   },

package/src/lib/operations/plans.mjs

@@ -0,0 +1,85 @@
+import { parseFrontmatter } from '../utils.mjs';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fs from 'fs/promises';
+
+/**
+ * List all plans in plans/current and plans/archive directories.
+ * @param {string} projectRoot - Absolute path to project root
+ * @param {{ status?: string }} [options] - Filter options
+ * @returns {Promise<Array<{id: string, title: string, status: string, path: string}>>}
+ */
+export async function listPlans(projectRoot, { status } = {}) {
+  const plansDirs = [
+    path.join(projectRoot, 'plans', 'current'),
+    path.join(projectRoot, 'plans', 'archive')
+  ];
+
+  const allPlans = [];
+
+  for (const plansDir of plansDirs) {
+    try {
+      const files = await fs.readdir(plansDir);
+      for (const file of files) {
+        if (!file.endsWith('.md')) continue;
+        const filePath = path.join(plansDir, file);
+        const content = await fs.readFile(filePath, 'utf8');
+        const { frontmatter } = parseFrontmatter(content);
+        if (status && frontmatter.status !== status) continue;
+        allPlans.push({
+          id: frontmatter.id || file.replace('.md', ''),
+          title: frontmatter.title || '',
+          status: frontmatter.status || 'unknown',
+          path: filePath
+        });
+      }
+    } catch (err) {
+      // If directory doesn't exist, just skip it
+      if (err.code !== 'ENOENT') throw err;
+    }
+  }
+
+  return allPlans;
+}
+
+/**
+ * Get a specific plan by ID.
+ * @param {string} projectRoot - Absolute path to project root
+ * @param {string} planId - Plan ID (e.g., 'PLAN-001')
+ * @returns {Promise<{frontmatter: object, body: string, path: string}>}
+ * @throws {Error} With code 'PLAN_NOT_FOUND' if plan not found
+ */
+export async function getPlan(projectRoot, planId) {
+  const plansDirs = [
+    path.join(projectRoot, 'plans', 'current'),
+    path.join(projectRoot, 'plans', 'archive')
+  ];
+
+  for (const plansDir of plansDirs) {
+    try {
+      const files = await fs.readdir(plansDir);
+      for (const file of files) {
+        if (!file.endsWith('.md')) continue;
+        // Normalize file name to plan ID format for comparison
+        const fileId = file.replace('.md', '');
+        if (fileId === planId || fileId.toUpperCase() === planId.toUpperCase()) {
+          const filePath = path.join(plansDir, file);
+          const content = await fs.readFile(filePath, 'utf8');
+          const { frontmatter, body } = parseFrontmatter(content);
+          return {
+            frontmatter,
+            body,
+            path: filePath
+          };
+        }
+      }
+    } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+    }
+  }
+
+  const error = new Error(`Plan not found: ${planId}`);
+  error.code = 'PLAN_NOT_FOUND';
+  error.planId = planId;
+  throw error;
+}

package/src/lib/operations/skills.mjs

@@ -0,0 +1,124 @@
+import { findProjectRoot } from '../find-root.mjs';
+import { existsSync, lstatSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Lists all available skills, distinguishing between shared and ejected ones.
+ * 
+ * @param {string} [projectRoot] - Project root directory. If not provided, will be auto-detected.
+ * @returns {Promise<Array<{name: string, path: string, source: 'shared' | 'ejected'}>>}
+ */
+export async function listSkills(projectRoot) {
+  // Auto-detect project root if not provided
+  if (!projectRoot) {
+    projectRoot = findProjectRoot();
+  }
+
+  // Get global skills directory (from where this module is located)
+  // Assuming this file is in src/lib/operations/skills.mjs
+  // Global root is two levels up from src (since src is in project root)
+  const globalRoot = join(projectRoot, '..');
+  const globalSkillsDir = join(globalRoot, 'src', 'skills');
+  
+  // Project skills directory
+  const projectSkillsDir = join(projectRoot, '.workflow', 'src', 'skills');
+
+  const result = [];
+
+  // Check if global skills directory exists
+  if (!existsSync(globalSkillsDir)) {
+    return result;
+  }
+
+  // Read global skills
+  const globalSkills = readdirSync(globalSkillsDir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory())
+    .map(entry => entry.name);
+
+  // Check if project skills directory exists
+  if (existsSync(projectSkillsDir)) {
+    // Check if it's a junction/symlink
+    let isJunctionLink = false;
+    try {
+      const stats = lstatSync(projectSkillsDir);
+      isJunctionLink = stats.isSymbolicLink();
+    } catch (error) {
+      // If lstat fails, treat as not a junction
+      isJunctionLink = false;
+    }
+
+    if (isJunctionLink) {
+      // If it's a junction, all skills in it are considered shared
+      const projectSkills = readdirSync(projectSkillsDir, { withFileTypes: true })
+        .filter(entry => entry.isDirectory())
+        .map(entry => entry.name);
+
+      // Add all skills as shared (from junction)
+      for (const skillName of [...new Set([...globalSkills, ...projectSkills])]) {
+        result.push({
+          name: skillName,
+          path: join(globalSkillsDir, skillName),
+          source: 'shared'
+        });
+      }
+    } else {
+      // Not a junction - handle ejected skills
+      const projectSkills = readdirSync(projectSkillsDir, { withFileTypes: true })
+        .filter(entry => entry.isDirectory())
+        .map(entry => entry.name);
+
+      // First, add all global skills as shared
+      for (const skillName of globalSkills) {
+        result.push({
+          name: skillName,
+          path: join(globalSkillsDir, skillName),
+          source: 'shared'
+        });
+      }
+
+      // Then, override with ejected skills where applicable
+      const ejectedSkillsMap = new Map();
+      for (const skillName of projectSkills) {
+        ejectedSkillsMap.set(skillName, join(projectSkillsDir, skillName));
+      }
+
+      // Build final result: ejected overrides shared
+      const finalResult = [];
+      const processedSkills = new Set();
+
+      // Add ejected skills first
+      for (const [skillName, skillPath] of ejectedSkillsMap) {
+        finalResult.push({
+          name: skillName,
+          path: skillPath,
+          source: 'ejected'
+        });
+        processedSkills.add(skillName);
+      }
+
+      // Add global skills that weren't overridden
+      for (const skillName of globalSkills) {
+        if (!processedSkills.has(skillName)) {
+          finalResult.push({
+            name: skillName,
+            path: join(globalSkillsDir, skillName),
+            source: 'shared'
+          });
+        }
+      }
+
+      return finalResult;
+    }
+  } else {
+    // No project skills directory - return all global skills as shared
+    for (const skillName of globalSkills) {
+      result.push({
+        name: skillName,
+        path: join(globalSkillsDir, skillName),
+        source: 'shared'
+      });
+    }
+  }
+
+  return result;
+}

package/src/lib/operations/tickets.mjs

@@ -0,0 +1,332 @@
+import { findProjectRoot } from '../find-root.mjs';
+import { parseFrontmatter, serializeFrontmatter, getLastReviewStatus, normalizePlanId } from '../utils.mjs';
+import { existsSync, readdirSync, promises as fs } from 'node:fs';
+import { resolve, join } from 'node:path';
+
+const VALID_STATUSES = [
+  "backlog", "ready", "in-progress", "blocked", "review", "done", "archive",
+];
+
+const VALID_TRANSITIONS = {
+  backlog: ["ready", "blocked", "done"],
+  ready: ["in-progress", "review", "backlog"],
+  "in-progress": ["done", "blocked", "review"],
+  blocked: ["ready"],
+  review: ["done", "ready", "in-progress", "blocked"],
+  done: ["ready", "blocked", "archive"],
+  archive: ["backlog"],
+};
+
+function formatNumber(num) {
+  return String(num).padStart(3, '0');
+}
+
+export async function getNextId(projectRoot, type) {
+  const root = projectRoot || findProjectRoot();
+  const ticketsDir = join(root, '.workflow', 'tickets');
+  if (!existsSync(ticketsDir)) return `${type}-001`;
+  const maxNum = findMaxNumber(ticketsDir, type);
+  return `${type}-${formatNumber(maxNum + 1)}`;
+}
+
+function findMaxNumber(targetDir, prefix) {
+  let maxNum = 0;
+  const regex = new RegExp(`^${prefix}-(\\d+)\\.md$`, "i");
+  function scanDirectory(dir) {
+    if (!existsSync(dir)) return;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) scanDirectory(fullPath);
+      else if (entry.isFile()) {
+        const match = entry.name.match(regex);
+        if (match) maxNum = Math.max(maxNum, parseInt(match[1], 10));
+      }
+    }
+  }
+  scanDirectory(targetDir);
+  return maxNum;
+}
+
+function getStatusFromPath(ticketId, ticketsDir) {
+  for (const status of VALID_STATUSES) {
+    if (existsSync(join(ticketsDir, status, `${ticketId}.md`))) return status;
+  }
+  return null;
+}
+
+function assertValidTransition(from, to) {
+  if (!VALID_STATUSES.includes(from) || !VALID_STATUSES.includes(to)) {
+    throw { code: 'INVALID_TRANSITION', from, to, id: null };
+  }
+  if (!VALID_TRANSITIONS[from]?.includes(to)) {
+    throw { code: 'INVALID_TRANSITION', from, to, id: null };
+  }
+}
+
+export async function moveTicket(projectRoot, id, target) {
+  const root = projectRoot || findProjectRoot();
+  const ticketsDir = join(root, '.workflow', 'tickets');
+  const from = getStatusFromPath(id, ticketsDir);
+  if (!from) throw { code: 'INVALID_TRANSITION', from: null, to: target, id };
+  assertValidTransition(from, target);
+
+  const sourcePath = join(ticketsDir, from, `${id}.md`);
+  const targetDir = join(ticketsDir, target);
+  const targetPath = join(targetDir, `${id}.md`);
+
+  let content = await fs.readFile(sourcePath, 'utf8');
+  let { frontmatter, body } = parseFrontmatter(content);
+  const now = new Date().toISOString();
+  frontmatter.updated_at = now;
+  if (target === "done" && from !== "done") frontmatter.completed_at = now;
+  if (target === "done" && from === "review" && getLastReviewStatus(content) === null) {
+    const date = now.slice(0, 16).replace("T", " ");
+    body = body.trimEnd() + `\n## Ревью\n\n| Дата | Статус | Самари |\n|------|--------|--------|\n| ${date} | ✅ passed | Pipeline fallback |\n`;
+  }
+  if (from === "blocked" && frontmatter.blocked_reason) delete frontmatter.blocked_reason;
+
+  const newContent = serializeFrontmatter(frontmatter) + body;
+  if (!existsSync(targetDir)) await fs.mkdir(targetDir, { recursive: true });
+  await fs.rename(sourcePath, targetPath);
+  await fs.writeFile(targetPath, newContent, 'utf8');
+  return { from, to: target, path: targetPath };
+}
+
+function checkCondition(projectRoot, condition) {
+  const { type, value } = condition;
+  switch (type) {
+    case 'file_exists': return existsSync(join(projectRoot, value));
+    case 'file_not_exists': return !existsSync(join(projectRoot, value));
+    case 'tasks_completed':
+      if (!value || (Array.isArray(value) && value.length === 0)) return true;
+      const ids = Array.isArray(value) ? value : [value];
+      const doneDir = join(projectRoot, '.workflow', 'tickets', 'done');
+      const archiveDir = join(projectRoot, '.workflow', 'tickets', 'archive');
+      return ids.every(tid => existsSync(join(doneDir, `${tid}.md`)) || existsSync(join(archiveDir, `${tid}.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: return true;
+  }
+}
+
+function checkDependencies(projectRoot, dependencies) {
+  if (!dependencies || dependencies.length === 0) return true;
+  const doneDir = join(projectRoot, '.workflow', 'tickets', 'done');
+  const archiveDir = join(projectRoot, '.workflow', 'tickets', 'archive');
+  return dependencies.every(depId =>
+    existsSync(join(doneDir, `${depId}.md`)) || existsSync(join(archiveDir, `${depId}.md`))
+  );
+}
+
+export async function createTicket(projectRoot, data) {
+  const root = projectRoot || findProjectRoot();
+  const ticketsDir = join(root, '.workflow', 'tickets');
+  const backlogDir = join(ticketsDir, 'backlog');
+  const type = data.type ?? 'impl';
+  const id = await getNextId(root, type);
+  const frontmatter = {
+    id, title: data.title ?? '', priority: data.priority ?? 3, type,
+    required_capabilities: data.required_capabilities ?? [],
+    created_at: new Date().toISOString(), updated_at: new Date().toISOString(), completed_at: '',
+    parent_plan: data.parent_plan ?? '', parent_task: data.parent_task ?? '',
+    dependencies: data.dependencies ?? [], conditions: data.conditions ?? [],
+    context: data.context ?? { files: [], references: [], notes: '' },
+    complexity: data.complexity ?? 'medium', tags: data.tags ?? [],
+  };
+  if (data.type === 'human') frontmatter.executor_type = 'human';
+  if (!existsSync(backlogDir)) await fs.mkdir(backlogDir, { recursive: true });
+  const path = join(backlogDir, `${id}.md`);
+  const content = serializeFrontmatter(frontmatter) + '\n## Описание\n\n\n## Критерии готовности (Definition of Done)\n\n- [ ] \n';
+  await fs.writeFile(path, content, 'utf8');
+  return { id, path };
+}
+
+/**
+ * Проверяет, заполнен ли раздел результатов (Summary) в тикете
+ */
+function hasFilledResult(body) {
+  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);
+  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);
+  const withoutComments = summaryContent.replace(/<!--[\s\S]*?-->/g, '').trim();
+  return withoutComments.length > 0;
+}
+
+function filterByPlan(tickets, planId) {
+  if (!planId) return tickets;
+  return tickets.filter(t => normalizePlanId(t.frontmatter.parent_plan) === planId);
+}
+
+function sortTickets(tickets) {
+  return tickets.sort((a, b) => {
+    const pa = a.frontmatter.priority || 999, pb = b.frontmatter.priority || 999;
+    if (pa !== pb) return pa - pb;
+    const da = new Date(a.frontmatter.created_at || '9999-12-31');
+    const db = new Date(b.frontmatter.created_at || '9999-12-31');
+    return da - db;
+  });
+}
+
+function isTicketEligible(projectRoot, ticket, checkDuplicates = [], currentDir = null) {
+  const { frontmatter, id } = ticket;
+  if (frontmatter.type === 'human') return false;
+  if (!checkDependencies(projectRoot, frontmatter.dependencies || [])) return false;
+  const conditions = frontmatter.conditions || [];
+  if (!conditions.every(c => checkCondition(projectRoot, c))) return false;
+
+  // Проверка дубликатов - исключаем тикет если он находится в других директориях
+  // checkDuplicates может быть true (исключить все кроме currentDir) или false/[] (не проверять)
+  if (checkDuplicates === true || (Array.isArray(checkDuplicates) && checkDuplicates.length > 0)) {
+    const allDirs = ['ready', 'done', 'in-progress', 'review', 'blocked'].filter(d => d !== currentDir).map(d =>
+      join(projectRoot, '.workflow', 'tickets', d));
+    if (allDirs.some(dir => existsSync(join(dir, `${id}.md`)))) return false;
+  }
+  return true;
+}
+
+/**
+ * Выбирает следующий доступный тикет (все статусы: found, in_review, completed_in_progress, in_progress, empty)
+ * @param {string} projectRoot - Корень проекта
+ * @param {string} planId - ID плана для фильтрации
+ * @returns {Promise<object>} Результат выбора
+ */
+export async function pickNext(projectRoot) {
+  const root = projectRoot || findProjectRoot();
+  const ticketsDir = join(root, '.workflow', 'tickets');
+  const readyDir = join(ticketsDir, 'ready');
+  const reviewDir = join(ticketsDir, 'review');
+  const inProgressDir = join(ticketsDir, 'in-progress');
+
+  // 1. ready/ тикеты
+  const readyFiles = existsSync(readyDir) ? readdirSync(readyDir).filter(f => f.endsWith('.md') && f !== '.gitkeep.md') : [];
+  const readyTickets = [];
+  for (const file of readyFiles) {
+    try {
+      const content = await fs.readFile(join(readyDir, file), 'utf8');
+      const { frontmatter } = parseFrontmatter(content);
+      readyTickets.push({ id: frontmatter.id || file.replace('.md', ''), frontmatter, filePath: join(readyDir, file) });
+    } catch (e) {}
+  }
+  if (readyTickets.length === 0) {
+    return { empty: true, reason: 'no_ready_tickets' };
+  }
+  const eligibleReady = readyTickets.filter(t => isTicketEligible(root, t, true, 'ready'));
+  if (eligibleReady.length > 0) {
+    const selected = sortTickets(eligibleReady)[0];
+    return { ticket: { id: selected.id, ...selected.frontmatter, path: selected.filePath } };
+  }
+  return { empty: true, reason: 'no_eligible_tickets' };
+}
+
+/**
+ * Оригинальная функция pickNext (только ready/) - для совместимости
+ */
+export async function pickNextEffective(projectRoot, planId) {
+  const root = projectRoot || findProjectRoot();
+  const ticketsDir = join(root, '.workflow', 'tickets');
+  const readyDir = join(ticketsDir, 'ready');
+  const reviewDir = join(ticketsDir, 'review');
+  const inProgressDir = join(ticketsDir, 'in-progress');
+
+  // 1. ready/
+  const readyFiles = existsSync(readyDir) ? readdirSync(readyDir).filter(f => f.endsWith('.md') && f !== '.gitkeep.md') : [];
+  const readyTickets = [];
+  for (const file of readyFiles) {
+    try {
+      const content = await fs.readFile(join(readyDir, file), 'utf8');
+      const { frontmatter } = parseFrontmatter(content);
+      readyTickets.push({ id: frontmatter.id || file.replace('.md', ''), frontmatter, filePath: join(readyDir, file) });
+    } catch (e) {}
+  }
+  const eligibleReady = readyTickets.filter(t => isTicketEligible(root, t, true, 'ready'));
+  if (eligibleReady.length > 0) {
+    const selected = sortTickets(eligibleReady)[0];
+    return { status: 'found', ticket_id: selected.id, priority: selected.frontmatter.priority,
+      title: selected.frontmatter.title, type: selected.frontmatter.type,
+      required_capabilities: JSON.stringify(selected.frontmatter.required_capabilities || []) };
+  }
+
+  // 2. review/
+  const reviewFiles = existsSync(reviewDir) ? readdirSync(reviewDir).filter(f => f.endsWith('.md') && f !== '.gitkeep.md') : [];
+  const reviewTickets = [];
+  for (const file of reviewFiles) {
+    try {
+      const content = await fs.readFile(join(reviewDir, file), 'utf8');
+      const { frontmatter } = parseFrontmatter(content);
+      reviewTickets.push({ id: frontmatter.id || file.replace('.md', ''), frontmatter, filePath: join(reviewDir, file) });
+    } catch (e) {}
+  }
+  if (reviewTickets.length > 0) {
+    const eligibleReview = reviewTickets.filter(t => isTicketEligible(root, t, true, 'review'));
+    if (eligibleReview.length > 0) {
+      const selected = sortTickets(eligibleReview)[0];
+      return { status: 'in_review', ticket_id: selected.id, priority: selected.frontmatter.priority,
+        title: selected.frontmatter.title, type: selected.frontmatter.type,
+        required_capabilities: JSON.stringify(selected.frontmatter.required_capabilities || []) };
+    }
+  }
+
+  // 3. in-progress/ завершённые
+  const inProgressFiles = existsSync(inProgressDir) ? readdirSync(inProgressDir).filter(f => f.endsWith('.md') && f !== '.gitkeep.md') : [];
+  const completedInProgress = [];
+  for (const file of inProgressFiles) {
+    try {
+      const content = await fs.readFile(join(inProgressDir, file), 'utf8');
+      const { frontmatter, body } = parseFrontmatter(content);
+      if (hasFilledResult(body)) {
+        completedInProgress.push({ id: frontmatter.id || file.replace('.md', ''), frontmatter, filePath: join(inProgressDir, file) });
+      }
+    } catch (e) {}
+  }
+  if (completedInProgress.length > 0) {
+    const eligibleCompleted = completedInProgress.filter(t => isTicketEligible(root, t, true, 'in-progress'));
+    if (eligibleCompleted.length > 0) {
+      const selected = sortTickets(eligibleCompleted)[0];
+      return { status: 'completed_in_progress', ticket_id: selected.id,
+        required_capabilities: JSON.stringify(selected.frontmatter.required_capabilities || []) };
+    }
+  }
+
+  // 4. in-progress/ незавершённые
+  const allInProgress = [];
+  for (const file of inProgressFiles) {
+    try {
+      const content = await fs.readFile(join(inProgressDir, file), 'utf8');
+      const { frontmatter, body } = parseFrontmatter(content);
+      if (!hasFilledResult(body)) {
+        allInProgress.push({ id: frontmatter.id || file.replace('.md', ''), frontmatter, filePath: join(inProgressDir, file) });
+      }
+    } catch (e) {}
+  }
+  if (allInProgress.length > 0) {
+    const eligibleInProgress = allInProgress.filter(t => isTicketEligible(root, t, true, 'in-progress'));
+    if (eligibleInProgress.length > 0) {
+      const selected = sortTickets(eligibleInProgress)[0];
+      return { status: 'in_progress', ticket_id: selected.id, priority: selected.frontmatter.priority,
+        title: selected.frontmatter.title, type: selected.frontmatter.type,
+        required_capabilities: JSON.stringify(selected.frontmatter.required_capabilities || []) };
+    }
+  }
+
+  // 5. пусто
+  return { status: 'empty', reason: 'No tickets in ready/' };
+}
+
+/**
+ * Оригинальная функция pickNext (только ready/) - для совместимости со старыми test
+ */