@work-graph/cli 0.2.0

package/vendor/src/workItemBvcQuality.mjs

@@ -0,0 +1,262 @@
+const BVC_FIELDS = ['basis', 'vector', 'goal'];
+
+const SECTION_TITLES = {
+  basis: 'Базис',
+  vector: 'Вектор',
+  goal: 'Цель',
+};
+
+export const WORK_ITEM_BVC_LIMITS = {
+  basis: { minLines: 2, minChars: 120 },
+  vector: { minLines: 2, minChars: 100 },
+  goal: { minLines: 1, minChars: 80 },
+};
+
+const DEPARTMENT_LABELS = {
+  'agent-platform': 'платформы агента',
+  'product-architecture': 'архитектуры продукта',
+  'knowledge-publishing': 'графа знаний и retrieval',
+  'domain-vertical': 'доменной вертикали',
+  'operator-ui': 'operator UI',
+};
+
+const compareText = (left, right) => String(left).localeCompare(String(right), 'ru', { sensitivity: 'variant' });
+
+export function sectionToLines(value) {
+  if (Array.isArray(value)) {
+    return value.map((line) => String(line).trim()).filter(Boolean);
+  }
+
+  return String(value ?? '')
+    .split(/\n+/u)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+export function measureBvcSection(lines) {
+  const normalized = sectionToLines(lines);
+  const text = normalized.join(' ');
+  const sentenceCount = (text.match(/[.!?…](?:\s|$)/gu) ?? []).length || (text.length > 0 ? 1 : 0);
+
+  return {
+    lineCount: normalized.length,
+    charCount: text.length,
+    sentenceCount,
+    lines: normalized,
+  };
+}
+
+export function meetsBvcLimits(lines, limits) {
+  const metrics = measureBvcSection(lines);
+  return metrics.lineCount >= limits.minLines && metrics.charCount >= limits.minChars;
+}
+
+export function evaluateWorkItemBvcQuality(item) {
+  const issues = [];
+
+  for (const field of BVC_FIELDS) {
+    const limits = WORK_ITEM_BVC_LIMITS[field];
+    const metrics = measureBvcSection(item[field]);
+    const workId = item.id ?? '';
+
+    if (metrics.lineCount < limits.minLines) {
+      issues.push({
+        severity: 'warning',
+        code: `short_${field}_lines`,
+        message: `${SECTION_TITLES[field]} для ${workId}: нужно минимум ${limits.minLines} строк(и), сейчас ${metrics.lineCount}`,
+        workId,
+        field,
+        lineCount: metrics.lineCount,
+        minLines: limits.minLines,
+      });
+    }
+
+    if (metrics.charCount < limits.minChars) {
+      issues.push({
+        severity: 'warning',
+        code: `short_${field}_chars`,
+        message: `${SECTION_TITLES[field]} для ${workId}: нужно минимум ${limits.minChars} символов, сейчас ${metrics.charCount}`,
+        workId,
+        field,
+        charCount: metrics.charCount,
+        minChars: limits.minChars,
+      });
+    }
+  }
+
+  return issues.sort((left, right) => compareText(left.workId, right.workId) || compareText(left.field, right.field));
+}
+
+function uniqueLines(lines) {
+  const seen = new Set();
+  const output = [];
+
+  for (const line of lines) {
+    const trimmed = String(line).trim();
+    if (trimmed === '' || seen.has(trimmed)) {
+      continue;
+    }
+    seen.add(trimmed);
+    output.push(trimmed);
+  }
+
+  return output;
+}
+
+function departmentLabel(department) {
+  return DEPARTMENT_LABELS[department] ?? 'Work Graph rebuild';
+}
+
+function formatList(items, limit = 4) {
+  const list = (items ?? []).filter(Boolean);
+  if (list.length === 0) {
+    return '';
+  }
+
+  if (list.length <= limit) {
+    return list.join(', ');
+  }
+
+  return `${list.slice(0, limit).join(', ')} и ещё ${list.length - limit}`;
+}
+
+function ensureSentence(text) {
+  const trimmed = String(text).trim();
+  if (trimmed === '') {
+    return '';
+  }
+
+  return /[.!?…]$/u.test(trimmed) ? trimmed : `${trimmed}.`;
+}
+
+function enrichBasis(lines, item) {
+  const output = [...lines];
+  const title = String(item.title ?? item.id ?? 'задача').trim();
+
+  if (output.length < 2) {
+    output.push(
+      ensureSentence(
+        `Задача «${title}» относится к контуру ${departmentLabel(item.department)} и должна быть понятна агенту без чтения всего backlog`,
+      ),
+    );
+  }
+
+  if ((item.dependsOn ?? []).length > 0 && !output.some((line) => line.includes('зависим'))) {
+    output.push(
+      ensureSentence(
+        `Предварительно должны быть закрыты зависимости: ${formatList(item.dependsOn)}`,
+      ),
+    );
+  }
+
+  if (item.status === 'blocked' && item.blocker && !output.some((line) => line.includes('блок'))) {
+    output.push(ensureSentence(`Сейчас задача заблокирована: ${item.blocker}`));
+  }
+
+  return uniqueLines(output);
+}
+
+function enrichVector(lines, item) {
+  const output = [...lines];
+  const title = String(item.title ?? item.id ?? 'задача').trim();
+
+  if (output.length < 2 && item.nextAction) {
+    output.push(ensureSentence(`Ближайший шаг исполнения: ${item.nextAction}`));
+  }
+
+  if ((item.targetFiles ?? []).length > 0) {
+    const targetLine = ensureSentence(`Основные артефакты изменений: ${formatList(item.targetFiles)}`);
+    if (!output.some((line) => line.includes('артефакты изменений'))) {
+      output.push(targetLine);
+    }
+  }
+
+  for (const check of item.checks ?? []) {
+    if (meetsBvcLimits(output, WORK_ITEM_BVC_LIMITS.vector)) {
+      break;
+    }
+
+    if (!output.some((line) => line.includes(check.slice(0, Math.min(24, check.length))))) {
+      output.push(ensureSentence(`Проверка результата: ${check}`));
+    }
+  }
+
+  if (!meetsBvcLimits(output, WORK_ITEM_BVC_LIMITS.vector) && output.length < 2) {
+    output.push(
+      ensureSentence(
+        `Работа ведётся итерациями с evidence и обновлением intent tree для «${title}»`,
+      ),
+    );
+  }
+
+  if (!meetsBvcLimits(output, WORK_ITEM_BVC_LIMITS.vector)) {
+    output.push(
+      ensureSentence(
+        `Изменения должны быть трассируемы через work.id=${item.id} и секцию Свидетельства`,
+      ),
+    );
+  }
+
+  return uniqueLines(output);
+}
+
+function enrichGoal(lines, item) {
+  const output = [...lines];
+  const title = String(item.title ?? item.id ?? 'задача').trim();
+
+  if (output.length === 0) {
+    output.push(ensureSentence(`Закрыть задачу «${title}» с проверяемым результатом для оператора и MCP-агента`));
+  }
+
+  const metrics = measureBvcSection(output);
+  if (metrics.charCount < WORK_ITEM_BVC_LIMITS.goal.minChars) {
+    if ((item.checks ?? []).length > 0) {
+      output.push(ensureSentence(`Готово, когда выполнены проверки: ${item.checks[0]}`));
+    } else {
+      output.push(
+        ensureSentence(
+          `Готово, когда изменения покрыты тестами или evidence и work.id=${item.id} можно перевести в done/verified`,
+        ),
+      );
+    }
+  }
+
+  return uniqueLines(output);
+}
+
+export function enrichWorkItemBvcDraft(draft, item = {}) {
+  const context = {
+    ...item,
+    title: item.title ?? draft.labels?.['work.title'] ?? draft.labels?.['work.id'] ?? draft.name,
+    department: item.department ?? draft.labels?.['work.department'] ?? '',
+    status: item.status ?? draft.labels?.['work.status'] ?? '',
+    nextAction: item.nextAction ?? draft.labels?.['work.next_action'] ?? '',
+    dependsOn: item.dependsOn ?? parseList(draft.labels?.['work.depends_on']),
+    targetFiles: item.targetFiles ?? parseList(draft.labels?.['work.target_files']),
+    checks: item.checks ?? draft.checks ?? [],
+    blocker: item.blocker ?? draft.labels?.['work.blocker'] ?? draft.labels?.['work.blocked_reason'] ?? '',
+    id: item.id ?? draft.labels?.['work.id'] ?? '',
+  };
+
+  return {
+    ...draft,
+    basis: enrichBasis(sectionToLines(draft.basis), context),
+    vector: enrichVector(sectionToLines(draft.vector), context),
+    goal: enrichGoal(sectionToLines(draft.goal), context),
+  };
+}
+
+export function needsWorkItemBvcEnrichment(item) {
+  return evaluateWorkItemBvcQuality(item).length > 0;
+}
+
+function parseList(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => String(entry).trim()).filter(Boolean);
+  }
+
+  return String(value ?? '')
+    .split(/\s*,\s*/u)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}

package/vendor/src/workItemCreateAnalysis.mjs

@@ -0,0 +1,157 @@
+import { PIPELINE_VERDICTS } from './workItemDecisionPipeline.mjs';
+import { formatVerdictRu, VERDICT_RU } from './pipelineProseRender.mjs';
+
+export { formatVerdictRu, VERDICT_RU };
+
+export function normalizeCreateWorkItemLines(value) {
+  if (value === undefined || value === null) {
+    return [];
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((line) => String(line).trim()).filter(Boolean);
+  }
+
+  return String(value)
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+
+function describeIntakeSource(args) {
+  const kind = String(args.intakeSourceKind ?? args.intake?.sourceKind ?? '').trim();
+  const ref = String(
+    args.intakeSourceRef
+    ?? args.intake?.sourceRef
+    ?? args.analyticsRef
+    ?? '',
+  ).trim();
+  const key = String(args.analyticsKey ?? args.intake?.analyticsKey ?? '').trim();
+
+  if (kind === 'analytics-record') {
+    if (key && ref) {
+      return `${key} (${ref})`;
+    }
+    return ref || key || 'запись аналитики';
+  }
+
+  if (kind !== '' && ref !== '') {
+    return `${kind}: ${ref}`;
+  }
+
+  if (kind !== '') {
+    return kind;
+  }
+
+  return ref;
+}
+
+
+export function buildDefaultWorkItemAnalysis(args = {}, verdict = 'useful') {
+  const basis = normalizeCreateWorkItemLines(args.basis);
+  const vector = normalizeCreateWorkItemLines(args.vector);
+  const goal = normalizeCreateWorkItemLines(args.goal);
+  const dependsOn = normalizeCreateWorkItemLines(args.dependsOn ?? args.depends_on);
+  const intake = describeIntakeSource(args);
+  const title = String(args.title ?? args.workId ?? 'задача').trim();
+
+  const why = basis[0]
+    || (intake ? `Закрывает пробел, выявленный в ${intake.split(' ')[0] ?? 'разборе'}.` : `Задача «${title}» нужна для текущего контура Work Graph.`);
+
+  const context = basis[1] || vector[0] || '';
+  const when = dependsOn.length > 0
+    ? `После готовности: ${dependsOn.join(', ')}.`
+    : 'Можно начинать, когда оператор перевёл задачу в ready.';
+  const doneWhen = goal[0] || `Достигнута цель задачи «${title}».`;
+
+  return [
+    'Зачем:',
+    why,
+    ...(context !== '' ? [`Контекст: ${context}`] : []),
+    'Когда:',
+    when,
+    'Готово, когда:',
+    doneWhen,
+  ];
+}
+
+export function buildDefaultWorkItemDecision(args = {}, verdict = 'useful') {
+  const dependsOn = normalizeCreateWorkItemLines(args.dependsOn ?? args.depends_on);
+  const verdictRu = formatVerdictRu(verdict);
+
+  return [
+    'Вердикт:',
+    verdictRu,
+    dependsOn.length > 0
+      ? `Брать в работу после закрытия зависимостей: ${dependsOn.join(', ')}.`
+      : 'Можно брать в работу после перевода в ready.',
+  ];
+}
+
+export function isLegacyEnglishAnalysisDecisionTemplate(text) {
+  return /actionable после intake-разбор|upstream deps|Scope drift|Verdict:\s*useful|intake \w/u.test(String(text ?? ''));
+}
+
+export function buildWorkItemCreateAnalysisDecision(args = {}) {
+  if (args.skipAnalysisDecision === true) {
+    return {
+      analysis: normalizeCreateWorkItemLines(args.analysis),
+      decision: normalizeCreateWorkItemLines(args.decision ?? args.decisionNotes),
+      pipelineLabels: {},
+    };
+  }
+
+  const requestedVerdict = String(args.decisionVerdict ?? args.verdict ?? 'useful').trim();
+  const verdict = PIPELINE_VERDICTS.includes(requestedVerdict) ? requestedVerdict : 'useful';
+
+  const analysis = normalizeCreateWorkItemLines(args.analysis);
+  const decision = normalizeCreateWorkItemLines(args.decision ?? args.decisionNotes);
+
+  const resolvedAnalysis = analysis.length > 0
+    ? analysis
+    : buildDefaultWorkItemAnalysis(args, verdict);
+  const resolvedDecision = decision.length > 0
+    ? decision
+    : buildDefaultWorkItemDecision(args, verdict);
+
+  const now = new Date().toISOString();
+  const pipelineLabels = {
+    'work.pipeline_stage': 'decided',
+    'work.analysis.at': now,
+    'work.analysis.source': String(
+      args.analysisSource ?? args.intakeSourceKind ?? 'create_work_item',
+    ).trim(),
+    'work.decision.verdict': verdict,
+    'work.decision.at': now,
+  };
+
+  const intakeRef = String(args.intakeSourceRef ?? args.analyticsRef ?? '').trim();
+  if (intakeRef !== '') {
+    pipelineLabels['intake.source_ref'] = intakeRef;
+  }
+
+  const analyticsKey = String(args.analyticsKey ?? '').trim();
+  if (analyticsKey !== '') {
+    pipelineLabels['intake.analytics_key'] = analyticsKey;
+  }
+
+  const intentQuestionId = String(args.intentQuestionId ?? args.intent_question_id ?? '').trim();
+  const intentOptionId = String(args.intentOptionId ?? args.intent_option_id ?? '').trim();
+  const intentDecisionId = String(args.intentDecisionId ?? args.intent_decision_id ?? '').trim();
+  if (intentQuestionId !== '') {
+    pipelineLabels['intent.question_id'] = intentQuestionId;
+  }
+  if (intentOptionId !== '') {
+    pipelineLabels['intent.option_id'] = intentOptionId;
+  }
+  if (intentDecisionId !== '') {
+    pipelineLabels['intent.decision_id'] = intentDecisionId;
+  }
+
+  return {
+    analysis: resolvedAnalysis,
+    decision: resolvedDecision,
+    pipelineLabels,
+  };
+}

package/vendor/src/workItemDecisionPipeline.mjs

@@ -0,0 +1,278 @@
+import {
+  applyAtomInspectorProposalToBacklogFile,
+  importStepAtomDraftForWorkItem,
+} from './atomInspector.mjs';
+import { readWorkItemsFromRepo } from './intentTreeWorkItems.mjs';
+
+export const WORK_PIPELINE_SCHEMA = 'workgraph.work-item.pipeline.v1';
+export const PIPELINE_STAGES = ['intake', 'analyzed', 'decided', 'ready', 'executing', 'closed'];
+export const PIPELINE_VERDICTS = ['useful', 'harmful', 'defer'];
+
+export function normalizePipelineLines(value) {
+  if (value === undefined || value === null) {
+    return [];
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((line) => String(line).trim()).filter(Boolean);
+  }
+
+  return String(value)
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+export function inferPipelineStage(item) {
+  const explicit = String(item?.labels?.['work.pipeline_stage'] ?? '').trim();
+  if (explicit !== '' && PIPELINE_STAGES.includes(explicit)) {
+    return explicit;
+  }
+
+  const verdict = String(item?.labels?.['work.decision.verdict'] ?? '').trim();
+  if (verdict !== '') {
+    return 'decided';
+  }
+
+  if (normalizePipelineLines(item?.analysis).length > 0) {
+    return 'analyzed';
+  }
+
+  if (item?.status === 'ready' || item?.status === 'claimed' || item?.status === 'doing' || item?.status === 'verify') {
+    return item.status === 'ready' ? 'ready' : 'executing';
+  }
+
+  if (item?.status === 'done' || item?.status === 'blocked') {
+    return 'closed';
+  }
+
+  return 'intake';
+}
+
+export function buildWorkItemPipelineView(item) {
+  if (!item) {
+    throw new TypeError('item is required');
+  }
+
+  const analysis = normalizePipelineLines(item.analysis);
+  const decision = normalizePipelineLines(item.decision);
+  const stage = inferPipelineStage(item);
+  const verdict = String(item.labels?.['work.decision.verdict'] ?? '').trim();
+
+  return {
+    schema: WORK_PIPELINE_SCHEMA,
+    workId: item.id,
+    stage,
+    verdict: PIPELINE_VERDICTS.includes(verdict) ? verdict : null,
+    analysis,
+    decision,
+    analysisAt: item.labels?.['work.analysis.at'] ?? null,
+    decisionAt: item.labels?.['work.decision.at'] ?? null,
+    status: item.status,
+  };
+}
+
+function mergeDraftWithPipelineFields(draft, patch) {
+  const next = {
+    ...draft,
+    labels: { ...(draft.labels ?? {}), ...(patch.labels ?? {}) },
+  };
+
+  if (patch.analysis !== undefined) {
+    next.analysis = normalizePipelineLines(patch.analysis);
+  }
+
+  if (patch.decision !== undefined) {
+    next.decision = normalizePipelineLines(patch.decision);
+  }
+
+  return next;
+}
+
+function applyVerdictToDraftLabels(draft, verdict, notes) {
+  const now = new Date().toISOString();
+  const labels = {
+    ...(draft.labels ?? {}),
+    'work.pipeline_stage': 'decided',
+    'work.decision.verdict': verdict,
+    'work.decision.at': now,
+  };
+
+  if (verdict === 'useful') {
+    labels['work.next_action'] = 'promote в ready после depends_on, затем claim/execute';
+    if (labels['work.blocker']) {
+      delete labels['work.blocker'];
+    }
+  } else if (verdict === 'harmful') {
+    labels['work.status'] = 'blocked';
+    labels['work.blocker'] = 'pipeline verdict harmful';
+    labels['work.next_action'] = 'review rejection; не исполнять';
+  } else if (verdict === 'defer') {
+    labels['work.next_action'] = 'defer: дождаться критериев пересмотра из анализа';
+  }
+
+  return mergeDraftWithPipelineFields(draft, {
+    labels,
+    decision: notes,
+  });
+}
+
+async function importWorkItemSource(workId, options) {
+  const { readWorkItemAtomFromRepo } = await import('./intentTreeWorkItems.mjs');
+  return readWorkItemAtomFromRepo(workId, options);
+}
+
+export async function applyWorkItemAnalysisToRepo(workId, analysisLines, options = {}) {
+  const sourceAtom = await importWorkItemSource(workId, options);
+  const source = importStepAtomDraftForWorkItem(sourceAtom.atomText, workId);
+
+  const now = new Date().toISOString();
+  const draft = mergeDraftWithPipelineFields(source.draft, {
+    analysis: analysisLines,
+    labels: {
+      'work.pipeline_stage': 'analyzed',
+      'work.analysis.at': now,
+      'work.analysis.source': options.analysisSource ?? 'cursor',
+      'work.next_action': options.nextAction ?? 'Cursor: record_work_item_decision (useful/harmful/defer)',
+    },
+  });
+
+  return applyAtomInspectorProposalToBacklogFile({
+    ...options,
+    workId,
+    draft,
+  });
+}
+
+export async function applyWorkItemDecisionToRepo(workId, verdict, options = {}) {
+  if (!PIPELINE_VERDICTS.includes(verdict)) {
+    throw new Error(`unsupported pipeline verdict: ${verdict}`);
+  }
+
+  const notes = normalizePipelineLines(options.notes);
+  if (notes.length === 0) {
+    throw new Error('decision notes are required — write them in Cursor and pass via record_work_item_decision');
+  }
+
+  const sourceAtom = await importWorkItemSource(workId, options);
+  const source = importStepAtomDraftForWorkItem(sourceAtom.atomText, workId);
+  const draft = applyVerdictToDraftLabels(source.draft, verdict, notes);
+
+  return applyAtomInspectorProposalToBacklogFile({
+    ...options,
+    workId,
+    draft,
+  });
+}
+
+export async function recordWorkItemAnalysis(options = {}) {
+  const workId = String(options.workId ?? '').trim();
+  if (workId === '') {
+    return { schema: WORK_PIPELINE_SCHEMA, ok: false, error: 'work_id_required' };
+  }
+
+  const analysisText = String(options.analysis ?? '').trim();
+  if (analysisText === '') {
+    return {
+      schema: WORK_PIPELINE_SCHEMA,
+      ok: false,
+      error: 'analysis_required',
+      message: 'analysis is required — produce it in Cursor (your connected LLM) and pass the full text',
+      workId,
+    };
+  }
+
+  const items = await readWorkItemsFromRepo(options);
+  const item = items.find((entry) => entry.id === workId);
+  if (!item) {
+    return { schema: WORK_PIPELINE_SCHEMA, ok: false, error: 'work_item_not_found', workId };
+  }
+
+  const analysisLines = normalizePipelineLines(analysisText);
+  const applyResult = await applyWorkItemAnalysisToRepo(workId, analysisLines, {
+    ...options,
+    analysisSource: options.analysisSource ?? 'cursor',
+  });
+
+  if (!applyResult.ok) {
+    return {
+      schema: WORK_PIPELINE_SCHEMA,
+      ok: false,
+      error: applyResult.error ?? 'apply_failed',
+      workId,
+      applyResult,
+    };
+  }
+
+  const refreshed = (await readWorkItemsFromRepo(options)).find((entry) => entry.id === workId);
+  return {
+    schema: WORK_PIPELINE_SCHEMA,
+    ok: true,
+    action: 'record_analysis',
+    workId,
+    pipeline: buildWorkItemPipelineView(refreshed),
+    path: applyResult.path,
+  };
+}
+
+export async function recordWorkItemDecision(options = {}) {
+  const workId = String(options.workId ?? '').trim();
+  const verdict = String(options.verdict ?? '').trim();
+
+  if (workId === '') {
+    return { schema: WORK_PIPELINE_SCHEMA, ok: false, error: 'work_id_required' };
+  }
+
+  if (!PIPELINE_VERDICTS.includes(verdict)) {
+    return {
+      schema: WORK_PIPELINE_SCHEMA,
+      ok: false,
+      error: 'invalid_verdict',
+      message: 'verdict must be useful | harmful | defer',
+      workId,
+    };
+  }
+
+  const notesText = String(options.notes ?? options.decision ?? '').trim();
+  if (notesText === '') {
+    return {
+      schema: WORK_PIPELINE_SCHEMA,
+      ok: false,
+      error: 'decision_notes_required',
+      message: 'notes/decision text is required — justify the verdict in Cursor before recording',
+      workId,
+    };
+  }
+
+  const items = await readWorkItemsFromRepo(options);
+  const item = items.find((entry) => entry.id === workId);
+  if (!item) {
+    return { schema: WORK_PIPELINE_SCHEMA, ok: false, error: 'work_item_not_found', workId };
+  }
+
+  const applyResult = await applyWorkItemDecisionToRepo(workId, verdict, {
+    ...options,
+    notes: notesText,
+  });
+
+  if (!applyResult.ok) {
+    return {
+      schema: WORK_PIPELINE_SCHEMA,
+      ok: false,
+      error: applyResult.error ?? 'apply_failed',
+      workId,
+      applyResult,
+    };
+  }
+
+  const refreshed = (await readWorkItemsFromRepo(options)).find((entry) => entry.id === workId);
+  return {
+    schema: WORK_PIPELINE_SCHEMA,
+    ok: true,
+    action: 'record_decision',
+    workId,
+    verdict,
+    pipeline: buildWorkItemPipelineView(refreshed),
+    path: applyResult.path,
+  };
+}