@work-graph/cli 0.2.0

package/vendor/src/pipelineProseRender.mjs

@@ -0,0 +1,180 @@
+export const VERDICT_RU = {
+  useful: 'полезно',
+  harmful: 'вредно',
+  defer: 'отложить',
+};
+
+export function formatVerdictRu(verdict) {
+  const key = String(verdict ?? '').trim();
+  return VERDICT_RU[key] ?? key;
+}
+
+function escapeHtml(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+const PIPELINE_INLINE_CODE_PATTERN = /(`[^`]+`|\bdepends_on=[^\s;,]+|\b(?:protocols|schemas|src|work|intent)\/(?:[\w.-]+\/)*[\w.-]+\.(?:bvc|step|json|mjs|md)\b|\b[\w.-]+\.(?:bvc|step|json|mjs|md)\b)/gu;
+
+export function renderPipelineInlineText(text) {
+  const tick = String.fromCharCode(96);
+  const source = String(text ?? '');
+  let result = '';
+  let lastIndex = 0;
+  let match;
+
+  PIPELINE_INLINE_CODE_PATTERN.lastIndex = 0;
+  while ((match = PIPELINE_INLINE_CODE_PATTERN.exec(source)) !== null) {
+    result += escapeHtml(source.slice(lastIndex, match.index));
+    const token = match[0];
+    if (token.startsWith(tick)) {
+      result += `<code class="inline-term">${escapeHtml(token.slice(1, -1))}</code>`;
+    } else {
+      result += `<code class="inline-term">${escapeHtml(token)}</code>`;
+    }
+    lastIndex = match.index + token.length;
+  }
+
+  result += escapeHtml(source.slice(lastIndex));
+  return result;
+}
+
+function isStandaloneSectionHeading(line) {
+  return /^[A-Za-zА-Яа-яЁё0-9][^:\n]{0,80}:$/u.test(line)
+    || /^[A-Za-zА-Яа-яЁё0-9][^:\n]{0,40}\s\/\s[^:\n]{0,40}:$/u.test(line);
+}
+
+function splitInlineSectionLine(line) {
+  const match = String(line ?? '').trim().match(/^([A-Za-zА-Яа-яЁё][^:]{0,78}):\s+(.+)$/u);
+  if (!match) {
+    return null;
+  }
+
+  return {
+    label: match[1].trim(),
+    body: match[2].trim(),
+  };
+}
+
+const PIPELINE_SECTION_LABELS = [
+  'Целесообразность',
+  'Контекст и границы',
+  'Вердикт',
+  'Решение',
+];
+
+export function normalizePipelineMultilineText(text) {
+  return String(text ?? '')
+    .replace(/\\n/g, '\n')
+    .replace(/\r\n/g, '\n');
+}
+
+function expandPipelineSectionLines(text) {
+  const normalized = normalizePipelineMultilineText(text);
+  /** @type {string[]} */
+  const expanded = [];
+
+  for (const rawLine of normalized.split('\n')) {
+    const line = rawLine.trim();
+    if (line === '') {
+      continue;
+    }
+
+    const pattern = new RegExp(
+      `(?:^|\\s)(${PIPELINE_SECTION_LABELS.join('|')}):\\s*`,
+      'gu',
+    );
+    const matches = [...line.matchAll(pattern)];
+    if (matches.length <= 1) {
+      expanded.push(line);
+      continue;
+    }
+
+    for (let index = 0; index < matches.length; index += 1) {
+      const match = matches[index];
+      const label = match[1];
+      const bodyStart = match.index + match[0].length;
+      const bodyEnd = index + 1 < matches.length ? matches[index + 1].index : line.length;
+      const body = line.slice(bodyStart, bodyEnd).trim();
+      expanded.push(`${label}: ${body}`);
+    }
+  }
+
+  return expanded;
+}
+
+export function renderPipelineProse(text) {
+  const lines = expandPipelineSectionLines(text);
+  const parts = [];
+  let listItems = [];
+  let listKind = null;
+
+  function flushList() {
+    if (listItems.length === 0) {
+      return;
+    }
+
+    const listClass = listKind === 'check'
+      ? 'pipeline-prose-list pipeline-prose-list--check'
+      : 'pipeline-prose-list';
+    parts.push(`<ul class="${listClass}">${
+      listItems.map((entry) => `<li>${renderPipelineInlineText(entry)}</li>`).join('')
+    }</ul>`);
+    listItems = [];
+    listKind = null;
+  }
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (line === '') {
+      flushList();
+      continue;
+    }
+
+    if (isStandaloneSectionHeading(line)) {
+      flushList();
+      parts.push(`<h4 class="pipeline-prose-heading">${escapeHtml(line.slice(0, -1))}</h4>`);
+      continue;
+    }
+
+    const inlineSection = splitInlineSectionLine(line);
+    if (inlineSection) {
+      flushList();
+      parts.push(`<h4 class="pipeline-prose-heading">${escapeHtml(inlineSection.label)}</h4>`);
+      parts.push(`<p class="pipeline-prose-p">${renderPipelineInlineText(inlineSection.body)}</p>`);
+      continue;
+    }
+
+    if (line.startsWith('- ') || line.startsWith('• ')) {
+      if (listKind && listKind !== 'bullet') {
+        flushList();
+      }
+      listKind = 'bullet';
+      listItems.push(line.slice(2));
+      continue;
+    }
+
+    if (line.startsWith('✓ ') || line.startsWith('✗ ') || line.startsWith('☑ ') || line.startsWith('☐ ')) {
+      if (listKind && listKind !== 'check') {
+        flushList();
+      }
+      listKind = 'check';
+      listItems.push(line);
+      continue;
+    }
+
+    flushList();
+    parts.push(`<p class="pipeline-prose-p">${renderPipelineInlineText(line)}</p>`);
+  }
+
+  flushList();
+  return `<div class="pipeline-prose">${parts.join('')}</div>`;
+}
+
+/** @deprecated use renderPipelineInlineText */
+export function renderInlineCode(text) {
+  return renderPipelineInlineText(text);
+}

package/vendor/src/pipelineStageLint.mjs

@@ -0,0 +1,118 @@
+import { inferPipelineStage, PIPELINE_VERDICTS } from './workItemDecisionPipeline.mjs';
+
+const DONE_STATUSES = new Set(['done', 'verified']);
+
+function isOperationalBypass(item) {
+  return String(item?.labels?.['work.intake.bypass'] ?? '').trim() === 'operational';
+}
+
+function hasAnalyticsIntake(item) {
+  const key = String(item?.labels?.['intake.analytics_key'] ?? '').trim();
+  const keys = String(item?.labels?.['intake.analytics_keys'] ?? '').trim();
+  return key !== '' || keys !== '';
+}
+
+function nonEmptySection(value) {
+  return String(value ?? '').trim().length > 0;
+}
+
+/**
+ * DoR/DoD checks for decision pipeline stages (AN-22 T3).
+ * Errors apply to explicit pipeline_stage mismatches; warnings tolerate legacy items.
+ *
+ * @param {Array<{ id: string, status: string, ownerRole?: string, analysis?: string, decision?: string, dependsOn?: string[], itemKind?: string, labels?: Record<string, string> }>} items
+ */
+export function lintPipelineStageIssues(items) {
+  if (!Array.isArray(items)) {
+    throw new TypeError('items must be an array');
+  }
+
+  const issues = [];
+  const doneIds = new Set(items.filter((item) => DONE_STATUSES.has(item.status)).map((item) => item.id));
+
+  for (const item of items) {
+    const bypass = isOperationalBypass(item);
+    const explicitStage = String(item.labels?.['work.pipeline_stage'] ?? '').trim();
+    const inferredStage = inferPipelineStage(item);
+    const stage = explicitStage !== '' ? explicitStage : inferredStage;
+
+    if (explicitStage === 'analyzed' && !nonEmptySection(item.analysis) && !bypass) {
+      issues.push({
+        severity: 'error',
+        code: 'pipeline_analyzed_without_analysis',
+        message: `WorkItem ${item.id} has work.pipeline_stage=analyzed but empty Анализ block`,
+        workId: item.id,
+        pipelineStage: explicitStage,
+      });
+    } else if (inferredStage === 'analyzed' && !nonEmptySection(item.analysis) && !bypass) {
+      issues.push({
+        severity: 'warning',
+        code: 'pipeline_inferred_analyzed_without_analysis',
+        message: `WorkItem ${item.id} infers analyzed stage but Анализ block is empty`,
+        workId: item.id,
+        pipelineStage: inferredStage,
+      });
+    }
+
+    if (explicitStage === 'decided' || (inferredStage === 'decided' && nonEmptySection(item.decision))) {
+      const verdict = String(item.labels?.['work.decision.verdict'] ?? '').trim();
+      if (!PIPELINE_VERDICTS.includes(verdict)) {
+        issues.push({
+          severity: explicitStage === 'decided' ? 'error' : 'warning',
+          code: 'pipeline_decided_without_verdict',
+          message: `WorkItem ${item.id} at decided stage missing valid work.decision.verdict`,
+          workId: item.id,
+          pipelineStage: stage,
+        });
+      }
+    }
+
+    if (item.status === 'ready' || stage === 'ready') {
+      if (!nonEmptySection(item.ownerRole) && !bypass) {
+        issues.push({
+          severity: 'warning',
+          code: 'pipeline_ready_without_owner',
+          message: `WorkItem ${item.id} is ready but work.owner_role is empty`,
+          workId: item.id,
+          status: item.status,
+        });
+      }
+
+      for (const dependencyId of item.dependsOn ?? []) {
+        if (!doneIds.has(dependencyId)) {
+          issues.push({
+            severity: 'error',
+            code: 'pipeline_ready_open_dependency',
+            message: `WorkItem ${item.id} is ready but dependency "${dependencyId}" is not done/verified`,
+            workId: item.id,
+            dependencyId,
+          });
+        }
+      }
+    }
+
+    if (!bypass && !hasAnalyticsIntake(item) && stage === 'intake' && item.status === 'backlog') {
+      issues.push({
+        severity: 'warning',
+        code: 'pipeline_intake_without_analytics',
+        message: `WorkItem ${item.id} at intake without intake.analytics_key and without work.intake.bypass=operational`,
+        workId: item.id,
+      });
+    }
+
+    if (String(item.itemKind ?? '') === 'epic' && DONE_STATUSES.has(item.status)) {
+      const closingRef = String(item.labels?.['analytics.closing_ref'] ?? '').trim();
+      if (closingRef === '') {
+        issues.push({
+          severity: 'warning',
+          code: 'epic_closed_without_closing_analysis',
+          message: `Epic ${item.id} is closed but analytics.closing_ref is not set (closing-AN pending)`,
+          workId: item.id,
+          status: item.status,
+        });
+      }
+    }
+  }
+
+  return issues;
+}

package/vendor/src/promptRulesEditorApi.mjs

@@ -0,0 +1,174 @@
+import { readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+
+import { buildPromptRulesProjection } from './promptRulesProjection.mjs';
+import { parseStepAtomDrafts } from './stepAtomFormatter.mjs';
+
+export const PROMPT_RULES_EDITOR_SCHEMA = 'workgraph.prompt-rules-editor.v1';
+export const PROMPT_RULES_EDITOR_ALLOWED_ROOT = 'rules/agent-behavior/';
+
+function normalizeRelativePath(filePath) {
+  return String(filePath ?? '').trim().replace(/\\/g, '/');
+}
+
+export function isPromptRulesEditorPathAllowed(filePath) {
+  const normalized = normalizeRelativePath(filePath);
+  return normalized.startsWith(PROMPT_RULES_EDITOR_ALLOWED_ROOT)
+    && (normalized.endsWith('.bvc') || normalized.endsWith('.bvc'));
+}
+
+export function validatePromptRuleSourceText(sourceText) {
+  const parsedAtoms = parseStepAtomDrafts(sourceText);
+  const promptRules = parsedAtoms.filter((parsed) => parsed.draft.profile === 'prompt_rule');
+  const errors = [];
+
+  if (promptRules.length === 0) {
+    errors.push('file must contain at least one prompt_rule atom');
+  }
+
+  for (const parsed of parsedAtoms) {
+    errors.push(...parsed.errors.map((message) => `${parsed.draft.name}: ${message}`));
+  }
+
+  return {
+    ok: errors.length === 0,
+    atomCount: parsedAtoms.length,
+    promptRuleCount: promptRules.length,
+    errors,
+  };
+}
+
+export async function readPromptRuleSource(options = {}) {
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const ruleId = String(options.ruleId ?? options.id ?? '').trim();
+  if (ruleId === '') {
+    throw new TypeError('ruleId is required');
+  }
+
+  const projection = await buildPromptRulesProjection({
+    cwd,
+    ruleId,
+    roots: ['rules/agent-behavior'],
+  });
+
+  const rule = projection.rules.find((entry) => entry.id === ruleId);
+  if (!rule) {
+    throw new Error(`prompt rule not found in ${PROMPT_RULES_EDITOR_ALLOWED_ROOT}: ${ruleId}`);
+  }
+
+  if (!isPromptRulesEditorPathAllowed(rule.filePath)) {
+    throw new Error(`prompt rule path not editable: ${rule.filePath}`);
+  }
+
+  const absolutePath = resolve(cwd, rule.filePath);
+  const sourceText = await readFile(absolutePath, 'utf8');
+  const validation = validatePromptRuleSourceText(sourceText);
+
+  return {
+    schema: PROMPT_RULES_EDITOR_SCHEMA,
+    ruleId,
+    filePath: rule.filePath,
+    sourceText,
+    rule,
+    validation,
+    editable: true,
+  };
+}
+
+async function writeTextAtomically(path, text) {
+  const tempPath = `${path}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile(tempPath, text, 'utf8');
+  await rename(tempPath, path);
+}
+
+export async function savePromptRuleSource(options = {}) {
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const filePath = normalizeRelativePath(options.filePath);
+  const sourceText = String(options.sourceText ?? '');
+
+  if (!isPromptRulesEditorPathAllowed(filePath)) {
+    return {
+      schema: 'workgraph.prompt-rules-editor.save.v1',
+      ok: false,
+      error: 'path_not_allowed',
+      filePath,
+      persisted: false,
+    };
+  }
+
+  const validation = validatePromptRuleSourceText(sourceText);
+  if (!validation.ok) {
+    return {
+      schema: 'workgraph.prompt-rules-editor.save.v1',
+      ok: false,
+      error: 'validation_failed',
+      filePath,
+      persisted: false,
+      validation,
+    };
+  }
+
+  const absolutePath = resolve(cwd, filePath);
+  if (options.persist !== false) {
+    await mkdirSafe(dirname(absolutePath));
+    await writeTextAtomically(absolutePath, sourceText.endsWith('\n') ? sourceText : `${sourceText}\n`);
+  }
+
+  return {
+    schema: 'workgraph.prompt-rules-editor.save.v1',
+    ok: true,
+    filePath,
+    persisted: options.persist !== false,
+    validation,
+  };
+}
+
+async function mkdirSafe(path) {
+  const { mkdir } = await import('node:fs/promises');
+  await mkdir(path, { recursive: true });
+}
+
+export function parsePromptRulesEditorRequestBody(rawBody) {
+  if (rawBody === undefined || rawBody === null) {
+    return {};
+  }
+
+  if (typeof rawBody === 'string' && rawBody.trim() === '') {
+    return {};
+  }
+
+  const body = typeof rawBody === 'string' ? JSON.parse(rawBody) : rawBody;
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    throw new TypeError('prompt rules editor body must be a JSON object');
+  }
+
+  return body;
+}
+
+export async function executePromptRuleSourceRead(options = {}) {
+  const body = parsePromptRulesEditorRequestBody(options.body ?? {});
+  const ruleId = String(options.ruleId ?? body.ruleId ?? body.id ?? '').trim();
+  return readPromptRuleSource({ cwd: options.cwd, ruleId });
+}
+
+export async function executePromptRuleSourceSave(options = {}) {
+  const body = parsePromptRulesEditorRequestBody(options.body ?? {});
+  const filePath = normalizeRelativePath(body.filePath);
+  const sourceText = String(body.sourceText ?? '');
+
+  if (filePath === '' || sourceText.trim() === '') {
+    return {
+      schema: 'workgraph.prompt-rules-editor.save.v1',
+      ok: false,
+      error: 'file_path_and_source_required',
+      persisted: false,
+    };
+  }
+
+  return savePromptRuleSource({
+    cwd: options.cwd,
+    filePath,
+    sourceText,
+    persist: body.persist !== false && options.persist !== false,
+  });
+}

package/vendor/src/promptRulesProjection.mjs

@@ -0,0 +1,134 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative, resolve } from 'node:path';
+
+import { parseStepAtomDrafts } from './stepAtomFormatter.mjs';
+
+export const PROMPT_RULES_PROJECTION_SCHEMA = 'workgraph.prompt-rules-projection.v1';
+export const PROMPT_RULES_SCAN_ROOTS = ['protocols', 'rules'];
+
+export async function collectStepFilePaths(cwd, roots = PROMPT_RULES_SCAN_ROOTS) {
+  const paths = [];
+
+  for (const root of roots) {
+    paths.push(...await walkStepFiles(resolve(cwd, root), cwd));
+  }
+
+  return [...new Set(paths)].sort((left, right) => left.localeCompare(right, 'en'));
+}
+
+async function walkStepFiles(directory, cwd) {
+  let entries;
+
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (error && typeof error === 'object' && error.code === 'ENOENT') {
+      return [];
+    }
+
+    throw error;
+  }
+
+  const paths = [];
+
+  for (const entry of entries) {
+    const absolutePath = join(directory, entry.name);
+
+    if (entry.isDirectory()) {
+      paths.push(...await walkStepFiles(absolutePath, cwd));
+      continue;
+    }
+
+    if (entry.isFile() && entry.name.endsWith('.bvc')) {
+      paths.push(relative(cwd, absolutePath).replace(/\\/g, '/'));
+    }
+  }
+
+  return paths;
+}
+
+export function buildPromptRuleProjectionEntry(filePath, parsed) {
+  const { draft, errors, warnings } = parsed;
+  const labels = draft.labels ?? {};
+  const ruleId = labels['rule.id']
+    ?? labels['protocol.id']
+    ?? labels['decision.id']
+    ?? draft.name;
+
+  return {
+    id: ruleId,
+    name: draft.name,
+    filePath,
+    profile: draft.profile,
+    basis: joinTextArray(draft.basis),
+    vector: joinTextArray(draft.vector),
+    goal: joinTextArray(draft.goal),
+    checks: joinTextArray(draft.checks ?? []),
+    evidence: joinTextArray(draft.evidence ?? []),
+    labels,
+    traceStatus: labels['trace.status'] ?? 'unknown',
+    protocolId: labels['protocol.id'] ?? null,
+    decisionId: labels['decision.id'] ?? null,
+    validationStatus: errors.length === 0 ? 'valid' : 'invalid',
+    validationErrors: errors,
+    validationWarnings: warnings,
+  };
+}
+
+export async function buildPromptRulesProjection(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const roots = options.roots ?? PROMPT_RULES_SCAN_ROOTS;
+  const ruleIdFilter = options.ruleId ? String(options.ruleId).trim() : '';
+  const filePaths = options.filePaths ?? await collectStepFilePaths(cwd, roots);
+  const rules = [];
+
+  for (const filePath of filePaths) {
+    const absolutePath = resolve(cwd, filePath);
+    const text = options.fileContents?.[filePath] ?? await readFile(absolutePath, 'utf8');
+    const parsedAtoms = parseStepAtomDrafts(text);
+
+    for (const parsed of parsedAtoms) {
+      if (parsed.draft.profile !== 'prompt_rule') {
+        continue;
+      }
+
+      const entry = buildPromptRuleProjectionEntry(filePath, parsed);
+      rules.push(entry);
+    }
+  }
+
+  rules.sort((left, right) => {
+    const byFile = left.filePath.localeCompare(right.filePath, 'en');
+    if (byFile !== 0) {
+      return byFile;
+    }
+
+    return left.id.localeCompare(right.id, 'en');
+  });
+
+  const filteredRules = ruleIdFilter
+    ? rules.filter((rule) => rule.id === ruleIdFilter)
+    : rules;
+
+  const validCount = rules.filter((rule) => rule.validationStatus === 'valid').length;
+
+  return {
+    schema: PROMPT_RULES_PROJECTION_SCHEMA,
+    scannedRoots: roots,
+    rules: filteredRules,
+    summary: {
+      total: rules.length,
+      valid: validCount,
+      invalid: rules.length - validCount,
+      filtered: filteredRules.length,
+    },
+  };
+}
+
+function joinTextArray(values) {
+  if (!Array.isArray(values) || values.length === 0) {
+    return '';
+  }
+
+  return values.map((value) => String(value).trim()).filter(Boolean).join('\n');
+}

package/vendor/src/pvrg/bladeAdapter.mjs

@@ -0,0 +1,40 @@
+/**
+ * PVRG language adapter stub for Blade templates (AN-21 P2).
+ * Registers *.blade.php as traceable UI artifacts alongside PHP/docs.
+ */
+export const BLADE_ADAPTER_ID = 'blade';
+
+/**
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+export function isBladeFile(filePath) {
+  return String(filePath ?? '').toLowerCase().endsWith('.blade.php');
+}
+
+/**
+ * Extract x-ui component tags for lightweight trace edges.
+ * @param {string} source
+ * @returns {string[]}
+ */
+export function extractBladeUiComponentRefs(source) {
+  const refs = new Set();
+  const pattern = /<x-ui\.([a-z0-9_.-]+)/gi;
+  let match = pattern.exec(source);
+  while (match) {
+    refs.add(`x-ui.${match[1]}`);
+    match = pattern.exec(source);
+  }
+  return [...refs];
+}
+
+/**
+ * @param {{ filePath: string, content: string }} file
+ */
+export function parseBladeFileForPvrg(file) {
+  return {
+    adapter: BLADE_ADAPTER_ID,
+    path: file.filePath,
+    uiComponentRefs: extractBladeUiComponentRefs(file.content ?? ''),
+  };
+}