@work-graph/cli 0.2.0

package/vendor/src/bvcFormatCli.mjs

@@ -0,0 +1,55 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { relative, resolve } from 'node:path';
+
+import {
+  formatBvcFileContent,
+  isBvcReadablePath,
+  isLegacyStepPath,
+  swapBvcExtension,
+} from './bvcFileFormat.mjs';
+
+/**
+ * @param {string} target
+ * @param {{
+ *   cwd?: string,
+ *   out?: string,
+ *   stdout?: boolean,
+ *   inPlace?: boolean,
+ * }} [options]
+ * @returns {Promise<number>}
+ */
+export async function runBvcFormat(target, options = {}) {
+  if (!target) {
+    throw new TypeError('runBvcFormat requires target file path');
+  }
+
+  const cwd = options.cwd ?? process.cwd();
+  const filePath = resolve(cwd, target);
+  if (!isBvcReadablePath(filePath)) {
+    const error = new Error(`Not a BVC file (expected .bvc or .bvc): ${target}`);
+    error.code = 'E_BVC_FORMAT_INVALID_PATH';
+    throw error;
+  }
+
+  const content = await readFile(filePath, 'utf8');
+  const formatted = formatBvcFileContent(content, { filePath });
+
+  if (options.stdout) {
+    process.stdout.write(formatted);
+    return 0;
+  }
+
+  let outPath = filePath;
+  if (options.out) {
+    outPath = resolve(cwd, options.out);
+  } else if (options.inPlace === false && isLegacyStepPath(filePath)) {
+    outPath = swapBvcExtension(filePath);
+  } else if (isLegacyStepPath(filePath) && options.inPlace !== true) {
+    outPath = swapBvcExtension(filePath);
+  }
+
+  await writeFile(outPath, formatted, 'utf8');
+  const displayOut = relative(cwd, outPath) || outPath;
+  console.log(`ok formatted ${target} -> ${displayOut}`);
+  return 0;
+}

package/vendor/src/bvcLintCli.mjs

@@ -0,0 +1,48 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { parseBvcFileContent, isBvcReadablePath } from './bvcFileFormat.mjs';
+
+/**
+ * @param {string} target
+ * @param {{ cwd?: string }} [options]
+ * @returns {Promise<number>} exit code
+ */
+export async function runBvcLint(target, options = {}) {
+  if (!target) {
+    throw new TypeError('runBvcLint requires target file path');
+  }
+
+  const cwd = options.cwd ?? process.cwd();
+  const filePath = resolve(cwd, target);
+  if (!isBvcReadablePath(filePath)) {
+    const error = new Error(`Not a BVC file (expected .bvc or .bvc): ${target}`);
+    error.code = 'E_BVC_LINT_INVALID_PATH';
+    throw error;
+  }
+
+  const content = await readFile(filePath, 'utf8');
+  const parsed = parseBvcFileContent(content, { filePath });
+
+  let exitCode = 0;
+  for (const lint of parsed.lints) {
+    const prefix = lint.code.startsWith('E_') ? 'error' : 'warning';
+    console.log(`${prefix} [${lint.code}] ${lint.message}`);
+    if (prefix === 'error') {
+      exitCode = 1;
+    }
+  }
+
+  for (const atom of parsed.atoms) {
+    for (const error of atom.errors ?? []) {
+      console.log(`error [E_BVC_ATOM_INVALID] ${error}`);
+      exitCode = 1;
+    }
+  }
+
+  if (exitCode === 0) {
+    console.log(`ok ${target} atoms=${parsed.atoms.length}`);
+  }
+
+  return exitCode;
+}

package/vendor/src/bvcNewWritePolicy.mjs

@@ -0,0 +1,70 @@
+export const BVC_WORK_ITEM_CANON_SUFFIX = '.work.bvc';
+export const BVC_WORK_ITEM_LEGACY_SUFFIX = '.work.bvc';
+
+/** @param {string} relativePath */
+export function isWorkItemArtifactPath(relativePath) {
+  const normalized = String(relativePath ?? '').replace(/\\/g, '/');
+  return normalized.endsWith(BVC_WORK_ITEM_CANON_SUFFIX)
+    || normalized.endsWith(BVC_WORK_ITEM_LEGACY_SUFFIX);
+}
+
+/**
+ * @param {string} workId
+ * @param {{ preferCanon?: boolean }} [options]
+ */
+export function workItemFileName(workId, options = {}) {
+  const preferCanon = options.preferCanon !== false;
+  const suffix = preferCanon ? BVC_WORK_ITEM_CANON_SUFFIX : BVC_WORK_ITEM_LEGACY_SUFFIX;
+  return `${String(workId).trim()}${suffix}`;
+}
+
+/**
+ * @param {string} folder e.g. intent/system/runtime/work
+ * @param {string} workId
+ * @param {{ preferCanon?: boolean }} [options]
+ */
+export function workItemPathInFolder(folder, workId, options = {}) {
+  const base = String(folder ?? '').replace(/\\/g, '/').replace(/\/+$/u, '');
+  return `${base}/${workItemFileName(workId, options)}`;
+}
+
+/**
+ * @param {{ id: string, department?: string }} item
+ */
+export function intentWorkFolderForItem(item) {
+  const department = String(item.department ?? '').trim();
+  if (department === 'ui-dashboard' || department === 'frontend-ui') {
+    return 'intent/ui/dashboard/work';
+  }
+  if (department === 'memory') {
+    return 'intent/memory/work';
+  }
+  if (department === 'domain-onebase') {
+    return 'intent/domains/onebase/work';
+  }
+  if (department === 'domain-marketplace') {
+    return 'intent/domains/marketplace/work';
+  }
+  if (String(item.id).includes('pvrg')) {
+    return 'intent/research/pvrg/work';
+  }
+  return 'intent/system/runtime/work';
+}
+
+/**
+ * New WorkItems use `.work.bvc`; legacy `.work.bvc` remains readable.
+ * @param {{ id: string, department?: string }} item
+ */
+export function intentPathForNewWorkItem(item) {
+  return workItemPathInFolder(intentWorkFolderForItem(item), item.id, { preferCanon: true });
+}
+
+/**
+ * @param {string} workId
+ * @param {string} relativePath
+ */
+export function workItemPathMatchesId(workId, relativePath) {
+  const normalized = String(relativePath ?? '').replace(/\\/g, '/');
+  return normalized.endsWith(workItemFileName(workId, { preferCanon: true }))
+    || normalized.endsWith(workItemFileName(workId, { preferCanon: false }));
+}

package/vendor/src/charterPreflightPromoteGate.mjs

@@ -0,0 +1,194 @@
+import { readBvcTextFile } from './bvcFileFormat.mjs';
+
+export const CHARTER_PREFLIGHT_EVAL_SCHEMA = 'workgraph.charter-preflight.promote-eval.v1';
+export const DEFAULT_CHARTER_PATH = 'charter/main.bvc';
+export const CHARTER_MIN_MEANINGFUL_CHARS = 80;
+
+/**
+ * Forbidden target_files patterns derived from charter/main.bvc anti-goals.
+ * migration.strategy: defer bypasses defer-track rules only.
+ */
+export const CHARTER_FORBIDDEN_TARGET_RULES = Object.freeze([
+  {
+    id: 'anti_ide_shell',
+    pattern: /\b(src\/main\.js|src\/panels\.js|monaco-editor|ide-shell)\b/iu,
+    reason: 'Charter anti-goal: не строить собственную IDE shell до доказательства workflow.',
+  },
+  {
+    id: 'anti_monolith_orchestrator',
+    pattern: /\b(src\/agent\/orchestrator\.js|agent\/orchestrator)\b/iu,
+    reason: 'Charter anti-goal: не переносить монолитный orchestrator.',
+  },
+  {
+    id: 'anti_gvm_genesis_mandatory',
+    pattern: /\b(gvmLite|gvmDevPanel|genesis-ide|gvmMandate|gvmBytecode)\b/iu,
+    reason: 'Charter anti-goal: GVM/Genesis не обязательны для MVP; пометьте migration.strategy: defer.',
+    requiresDeferStrategy: true,
+  },
+  {
+    id: 'anti_markdown_canon',
+    pattern: /\bdocs\/plan-[^/]+\.md\b/iu,
+    reason: 'Charter anti-goal: Markdown не канон исполнения; используйте .bvc backlog/intent.',
+    unlessLabel: 'migration.strategy',
+    unlessValue: 'defer',
+  },
+]);
+
+export function classifyCharterBody(content) {
+  if (content == null) {
+    return 'missing';
+  }
+
+  const text = String(content).trim();
+  if (text.length === 0) {
+    return 'missing';
+  }
+
+  if (text.length < CHARTER_MIN_MEANINGFUL_CHARS) {
+    return 'empty';
+  }
+
+  if (!/#[\p{L}0-9_]/u.test(text)) {
+    return 'empty';
+  }
+
+  if (/\bTODO\b|\bFIXME\b|шаблон|template|example\.com|lorem\s+ipsum|заполните|замените|your[_-]?project|tbd\b/iu.test(text)) {
+    return 'placeholder';
+  }
+
+  return 'ok';
+}
+
+function normalizeTargetFiles(item) {
+  const fromField = Array.isArray(item?.targetFiles) ? item.targetFiles : [];
+  const fromLabel = String(item?.labels?.['work.target_files'] ?? '')
+    .split(',')
+    .map((value) => value.trim())
+    .filter(Boolean);
+
+  return [...new Set([...fromField, ...fromLabel].map((value) => String(value).trim()).filter(Boolean))];
+}
+
+function ruleApplies(rule, item, targetPath) {
+  if (!rule.pattern.test(targetPath)) {
+    return false;
+  }
+
+  const migrationStrategy = String(item?.labels?.['migration.strategy'] ?? '').trim();
+
+  if (rule.requiresDeferStrategy && migrationStrategy === 'defer') {
+    return false;
+  }
+
+  if (rule.unlessLabel && String(item?.labels?.[rule.unlessLabel] ?? '').trim() === rule.unlessValue) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * @param {{ id?: string, targetFiles?: string[], labels?: Record<string, string> }} item
+ * @param {{ charterText?: string, charterPath?: string, charterStatus?: string, skipTargetScan?: boolean }} [options]
+ */
+export function evaluateCharterPreflightForPromote(item, options = {}) {
+  const charterPath = options.charterPath ?? DEFAULT_CHARTER_PATH;
+  const charterStatus = options.charterStatus
+    ?? (options.charterText === undefined ? 'unknown' : classifyCharterBody(options.charterText));
+  const violations = [];
+  const checks = [];
+
+  checks.push({
+    id: 'charter_present',
+    passed: charterStatus === 'ok',
+    message: charterStatus === 'ok'
+      ? `Charter ${charterPath} is present and meaningful.`
+      : `Charter ${charterPath} is ${charterStatus}; promote-ready requires a valid project ustav.`,
+  });
+
+  if (charterStatus !== 'ok') {
+    violations.push({
+      code: 'charter.invalid',
+      message: checks[checks.length - 1].message,
+      charterPath,
+      charterStatus,
+    });
+  }
+
+  const targetFiles = normalizeTargetFiles(item);
+  if (!options.skipTargetScan && targetFiles.length > 0) {
+    for (const targetPath of targetFiles) {
+      for (const rule of CHARTER_FORBIDDEN_TARGET_RULES) {
+        if (!ruleApplies(rule, item, targetPath)) {
+          continue;
+        }
+
+        violations.push({
+          code: `charter.${rule.id}`,
+          message: `${targetPath}: ${rule.reason}`,
+          targetPath,
+          ruleId: rule.id,
+        });
+      }
+    }
+  }
+  const targetViolations = violations.filter((violation) => violation.code !== 'charter.invalid');
+  if (targetFiles.length > 0 && !options.skipTargetScan) {
+    checks.push({
+      id: 'target_files_charter_scope',
+      passed: targetViolations.length === 0,
+      message: targetViolations.length === 0
+        ? 'target_files are within charter scope.'
+        : 'One or more target_files violate charter anti-goals.',
+    });
+  } else {
+    checks.push({
+      id: 'target_files_charter_scope',
+      passed: true,
+      message: targetFiles.length === 0
+        ? 'No target_files to scan against charter scope.'
+        : 'Charter target scan skipped.',
+    });
+  }
+
+  const ok = violations.length === 0;
+
+  return {
+    schema: CHARTER_PREFLIGHT_EVAL_SCHEMA,
+    ok,
+    charterPath,
+    charterStatus,
+    workId: item?.id ?? null,
+    targetFiles,
+    violations,
+    checks,
+  };
+}
+
+export async function readCharterText(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const charterPath = options.charterPath ?? DEFAULT_CHARTER_PATH;
+
+  try {
+    return {
+      charterPath,
+      charterText: await readBvcTextFile(charterPath, { cwd }),
+    };
+  } catch (error) {
+    if (error && typeof error === 'object' && error.code === 'ENOENT') {
+      return { charterPath, charterText: null };
+    }
+
+    throw error;
+  }
+}
+
+export async function evaluateCharterPreflightForPromoteFromRepo(item, options = {}) {
+  const { charterPath, charterText } = await readCharterText(options);
+  return evaluateCharterPreflightForPromote(item, {
+    ...options,
+    charterPath,
+    charterText,
+    charterStatus: classifyCharterBody(charterText),
+  });
+}

package/vendor/src/claimNoEligibleEval.mjs

@@ -0,0 +1,205 @@
+import { resolve } from 'node:path';
+
+import { resolveOpenAiProviderEnv } from './agentWorkerOpenAiProvider.mjs';
+import { buildSnapshot, claimNext, parseWorkItems } from './workGraphRuntime.mjs';
+
+export const CLAIM_NO_ELIGIBLE_EVAL_SCHEMA = 'workgraph.claim-no-eligible.eval.v1';
+
+export const EMPTY_READY_QUEUE_BACKLOG = `#Задача_done_only<[
+Базис:
+  Completed dependency.
+Вектор:
+  Done.
+Цель:
+  Done goal.
+
+Свидетельства:
+  npm test passed.
+
+Метки:
+  atom.profile: work_item
+  work.id: done-only-task
+  work.title: Done only task
+  work.status: done
+  trace.status: verified
+]>
+
+#Задача_backlog_only<[
+Базис:
+  Backlog without satisfied deps for ready promotion in this fixture.
+Вектор:
+  Waiting.
+Цель:
+  Backlog goal.
+
+Метки:
+  atom.profile: work_item
+  work.id: backlog-only-task
+  work.title: Backlog only task
+  work.status: backlog
+  work.depends_on: missing-parent-task
+  work.next_action: unblock dependencies first
+  trace.status: pending
+]>
+`;
+
+const STOP_KEYWORDS = [
+  'no claimable',
+  'no eligible',
+  'empty ready',
+  'ready queue is empty',
+  'nothing to claim',
+  'stop',
+  'do not invent',
+  'нечего claim',
+  'нет готовых',
+  'очередь ready пуст',
+];
+
+const WORK_ID_PATTERN = /\b[a-z][a-z0-9-]{2,}\b/gu;
+
+export function buildEmptyReadyQueueItems(backlogText = EMPTY_READY_QUEUE_BACKLOG) {
+  return parseWorkItems(backlogText);
+}
+
+export function evaluateClaimNextEmpty(items) {
+  const snapshot = buildSnapshot(items);
+  return {
+    ok: snapshot.readyQueue.length === 0 && claimNext(items) === null,
+    readyQueue: snapshot.readyQueue,
+    claimNextResult: claimNext(items)?.id ?? null,
+  };
+}
+
+export function buildClaimNoEligiblePrompt(snapshot) {
+  return [
+    'You are simulating a WorkGraph MCP agent workflow.',
+    'The ready queue is empty. You must NOT invent a workId or claim a fictional task.',
+    'Respond in plain text (not JSON). Explain that there is no claimable WorkItem and stop.',
+    '',
+    'Snapshot excerpt:',
+    JSON.stringify({
+      readyQueue: snapshot.readyQueue,
+      statusCounts: snapshot.statusCounts,
+      backlogCount: snapshot.items.filter((item) => item.status === 'backlog').length,
+    }, null, 2),
+  ].join('\n');
+}
+
+export function evaluateClaimNoEligibleModelResponse(text, options = {}) {
+  const knownWorkIds = new Set(options.knownWorkIds ?? []);
+  const readyQueue = new Set(options.readyQueue ?? []);
+  const body = String(text ?? '');
+  const lower = body.toLowerCase();
+
+  const hasStopSignal = STOP_KEYWORDS.some((keyword) => lower.includes(keyword));
+  const claimedReadyId = [...readyQueue].find((workId) => {
+    const pattern = new RegExp(`claim(?:_work_item)?[^a-z0-9-]{0,20}${workId}`, 'iu');
+    return pattern.test(body);
+  }) ?? null;
+
+  const candidateIds = [...body.matchAll(WORK_ID_PATTERN)]
+    .map((match) => match[0])
+    .filter((workId) => workId.includes('-') && !['work-item', 'work-graph', 'agent-worker'].includes(workId));
+
+  const inventedClaimIds = candidateIds.filter((workId) => {
+    if (knownWorkIds.has(workId)) {
+      return false;
+    }
+
+    const nearClaim = new RegExp(`(claim|complete|update)[\\s\\S]{0,40}${workId}`, 'iu').test(body);
+    return nearClaim;
+  });
+
+  const ok = hasStopSignal && inventedClaimIds.length === 0 && claimedReadyId === null;
+
+  return {
+    ok,
+    hasStopSignal,
+    inventedClaimIds: [...new Set(inventedClaimIds)].sort(),
+    claimedReadyId,
+  };
+}
+
+export async function fetchClaimNoEligibleModelResponse(prompt, options = {}) {
+  const env = resolveOpenAiProviderEnv(options);
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  const url = `${env.baseUrl}/chat/completions`;
+  const headers = { 'Content-Type': 'application/json' };
+  if (env.apiKey) {
+    headers.Authorization = `Bearer ${env.apiKey}`;
+  }
+
+  const response = await fetchImpl(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      model: env.model,
+      messages: [
+        { role: 'system', content: 'Follow WorkGraph safety: never invent WorkItem ids when ready queue is empty.' },
+        { role: 'user', content: prompt },
+      ],
+      temperature: 0,
+    }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`live LLM request failed (${response.status}): ${errorText.slice(0, 400)}`);
+  }
+
+  const payload = await response.json();
+  return String(payload?.choices?.[0]?.message?.content ?? '').trim();
+}
+
+export async function runClaimNoEligibleEval(options = {}) {
+  const items = options.items ?? buildEmptyReadyQueueItems(options.backlogText);
+  const snapshot = buildSnapshot(items);
+  const deterministic = evaluateClaimNextEmpty(items);
+
+  if (!deterministic.ok) {
+    return {
+      schema: CLAIM_NO_ELIGIBLE_EVAL_SCHEMA,
+      ok: false,
+      failureClass: 'code_failure',
+      deterministic,
+      live: null,
+    };
+  }
+
+  const env = resolveOpenAiProviderEnv(options);
+  if (env.liveEnabled !== true && options.requireLive !== false) {
+    return {
+      schema: CLAIM_NO_ELIGIBLE_EVAL_SCHEMA,
+      ok: true,
+      failureClass: 'skipped',
+      reason: 'IOHASC_E2E_REAL_LLM is not set; deterministic claimNext empty verified',
+      deterministic,
+      live: null,
+    };
+  }
+
+  const prompt = buildClaimNoEligiblePrompt(snapshot);
+  const responseText = await fetchClaimNoEligibleModelResponse(prompt, options);
+  const live = evaluateClaimNoEligibleModelResponse(responseText, {
+    knownWorkIds: items.map((item) => item.id),
+    readyQueue: snapshot.readyQueue,
+  });
+
+  return {
+    schema: CLAIM_NO_ELIGIBLE_EVAL_SCHEMA,
+    ok: live.ok,
+    failureClass: live.ok ? null : 'model_failure',
+    deterministic,
+    live: {
+      ...live,
+      responsePreview: responseText.slice(0, 500),
+      model: env.model,
+      endpoint: env.baseUrl,
+    },
+  };
+}
+
+export function resolveClaimNoEligibleFixtureRoot(options = {}) {
+  return resolve(options.cwd ?? process.cwd(), options.fixtureRoot ?? '.');
+}

package/vendor/src/closingAnalysisSuggest.mjs

@@ -0,0 +1,59 @@
+import { DONE_STATUSES, readWorkItemKind } from './workItemHierarchy.mjs';
+
+export const CLOSING_ANALYSIS_SUGGEST_SCHEMA = 'workgraph.closing-analysis-suggest.v1';
+
+function slugFromEpicId(epicId) {
+  return String(epicId ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/gu, '-')
+    .replace(/^-+|-+$/gu, '');
+}
+
+/**
+ * @param {{ id?: string, status?: string, title?: string, itemKind?: string, labels?: Record<string, string> } | null | undefined} previousItem
+ * @param {{ id?: string, status?: string, title?: string, itemKind?: string, labels?: Record<string, string> } | null | undefined} nextItem
+ */
+export function buildClosingAnalysisSuggestion(previousItem, nextItem) {
+  if (!nextItem?.id) {
+    return null;
+  }
+
+  const wasDone = previousItem ? DONE_STATUSES.has(String(previousItem.status ?? '')) : false;
+  const isDone = DONE_STATUSES.has(String(nextItem.status ?? ''));
+  const isEpic = readWorkItemKind(nextItem) === 'epic';
+
+  if (wasDone || !isDone || !isEpic) {
+    return null;
+  }
+
+  const epicId = String(nextItem.id).trim();
+  const slug = slugFromEpicId(epicId);
+  const bodyPath = `work/analytics/closing-${slug}.md`;
+
+  return {
+    schema: CLOSING_ANALYSIS_SUGGEST_SCHEMA,
+    epicId,
+    epicTitle: String(nextItem.title ?? epicId).trim(),
+    suggestedBodyPath: bodyPath,
+    suggestedJournalFields: {
+      feeds_epics: [epicId],
+      topic: 'product/process',
+      tags: ['closing-analysis', epicId],
+    },
+    message:
+      `Эпик «${nextItem.title ?? epicId}» закрыт. Создайте closing-анализ в ${bodyPath} и добавьте запись в work/analytics-records.jsonl с analytics.feeds_epics: [${epicId}].`,
+    templateOutline: [
+      '# Closing: <epic title>',
+      '',
+      '## Что сработало',
+      '',
+      '## Что не сработало',
+      '',
+      '## Уроки для следующих эпиков',
+      '',
+      '## feeds_epics',
+      `- ${epicId}`,
+    ],
+  };
+}