@work-graph/cli 0.2.5 → 0.2.6

package/vendor/src/stepAtomFormatter.mjs

@@ -13,6 +13,7 @@ import {
   scanBvcSectionDialects,
   stripBvcFilePragmaLine,
 } from './bvcAtomParser.mjs';
+import { validateStructuredEvidenceDraftArray } from './structuredEvidenceV1.mjs';
 
 const ALLOWED_PROFILES = new Set([
   'charter',
@@ -62,6 +63,7 @@ export function validateStepAtomDraft(draft) {
   validateTextArray(draft.goal, 'goal', errors, { required: true });
   validateTextArray(draft.checks, 'checks', errors, { required: false });
   validateTextArray(draft.evidence, 'evidence', errors, { required: false });
+  errors.push(...validateStructuredEvidenceDraftArray(draft.structuredEvidence));
   validateLabels(draft.labels, errors);
   validateLang(draft.lang, errors);
 

package/vendor/src/structuredEvidenceV1.mjs

@@ -0,0 +1,271 @@
+import { buildWorkItemContractV1 } from './workItemContractProjection.mjs';
+import { legacyEvidenceMatchesTierA, validateEvidenceForContract } from './workItemReadyForDone.mjs';
+
+export const STRUCTURED_EVIDENCE_TYPES = new Set([
+  'command',
+  'test',
+  'file',
+  'change',
+  'decision',
+  'worker-run',
+  'manual-review',
+  'blocker',
+]);
+
+export const STRUCTURED_EVIDENCE_STATUSES = new Set([
+  'succeeded',
+  'failed',
+  'pending',
+  'skipped',
+  'blocked',
+]);
+
+export function isStructuredEvidenceRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function parseStructuredEvidenceJson(input) {
+  if (isStructuredEvidenceRecord(input)) {
+    return input;
+  }
+
+  const text = String(input ?? '').trim();
+  if (text === '') {
+    throw new TypeError('structured evidence JSON is required');
+  }
+
+  const parsed = JSON.parse(text);
+  if (!isStructuredEvidenceRecord(parsed)) {
+    throw new TypeError('structured evidence must be a JSON object');
+  }
+
+  return parsed;
+}
+
+export function validateStructuredEvidenceShape(record) {
+  const violations = [];
+
+  if (!isStructuredEvidenceRecord(record)) {
+    return [{
+      code: 'invalid_structured_evidence',
+      severity: 'error',
+      message: 'structured evidence must be an object',
+      fix: 'pass evidence-record.v1 shaped JSON',
+    }];
+  }
+
+  const type = String(record.type ?? '').trim();
+  if (type === '' || !STRUCTURED_EVIDENCE_TYPES.has(type)) {
+    violations.push({
+      code: 'invalid_evidence_type',
+      severity: 'error',
+      message: `type must be one of: ${[...STRUCTURED_EVIDENCE_TYPES].join(', ')}`,
+      fix: 'set type to command or test for Tier A gates',
+    });
+  }
+
+  const status = String(record.status ?? '').trim();
+  if (status === '' || !STRUCTURED_EVIDENCE_STATUSES.has(status)) {
+    violations.push({
+      code: 'invalid_evidence_status',
+      severity: 'error',
+      message: `status must be one of: ${[...STRUCTURED_EVIDENCE_STATUSES].join(', ')}`,
+      fix: 'set status to succeeded',
+    });
+  }
+
+  if (type === 'command' || type === 'test') {
+    const command = String(record.command ?? record.cmd ?? '').trim();
+    if (command === '') {
+      violations.push({
+        code: 'missing_command',
+        severity: 'error',
+        message: 'command/test evidence requires command',
+        fix: 'set command field',
+      });
+    }
+
+    const exitCode = record.exitCode ?? record.exit_code;
+    if (exitCode === undefined || exitCode === null || Number.isNaN(Number(exitCode))) {
+      violations.push({
+        code: 'missing_exit_code',
+        severity: 'error',
+        message: 'command/test evidence requires exitCode',
+        fix: 'set exitCode to 0',
+      });
+    }
+  }
+
+  return violations;
+}
+
+export function normalizeStructuredEvidenceRecord(record, workId) {
+  const normalized = { ...record };
+  normalized.type = String(normalized.type ?? '').trim();
+  normalized.status = String(normalized.status ?? 'succeeded').trim();
+  normalized.taskId = String(normalized.taskId ?? workId ?? '').trim();
+  normalized.command = String(normalized.command ?? normalized.cmd ?? '').trim();
+  if (normalized.command !== '') {
+    normalized.cmd = normalized.command;
+  }
+  if (normalized.exitCode === undefined && normalized.exit_code !== undefined) {
+    normalized.exitCode = normalized.exit_code;
+  }
+  if (normalized.summary === undefined || String(normalized.summary).trim() === '') {
+    normalized.summary = normalized.command !== ''
+      ? `${normalized.command} exitCode=${normalized.exitCode ?? 0}`
+      : `${normalized.type} evidence`;
+  }
+  return normalized;
+}
+
+export function formatStructuredEvidenceStorageLine(record, workId) {
+  const normalized = normalizeStructuredEvidenceRecord(record, workId);
+  return JSON.stringify(normalized);
+}
+
+export function extractStructuredEvidenceRecords(item) {
+  const records = [];
+
+  for (const line of item?.evidence ?? []) {
+    const trimmed = String(line).trim();
+    if (!trimmed.startsWith('{')) {
+      continue;
+    }
+
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (isStructuredEvidenceRecord(parsed)) {
+        records.push(parsed);
+      }
+    } catch {
+      // ignore malformed JSON evidence lines
+    }
+  }
+
+  return records;
+}
+
+/**
+ * Prepare evidence lines to append with optional Tier A strict validation.
+ */
+export function prepareWorkItemEvidenceAppend(item, args = {}, options = {}) {
+  const workId = item.id;
+  const allItems = options.allItems ?? [item];
+  const contract = options.contract ?? buildWorkItemContractV1(item, { allItems });
+  const strictTierA = contract.verification?.tier === 'A';
+  const prose = String(args.evidence ?? args.summary ?? '').trim();
+  const hasStructuredInput = args.structuredEvidence !== undefined
+    || args.structured_evidence !== undefined
+    || args.evidenceJson !== undefined;
+
+  let structuredRecord = null;
+  if (hasStructuredInput) {
+    try {
+      structuredRecord = normalizeStructuredEvidenceRecord(
+        parseStructuredEvidenceJson(args.structuredEvidence ?? args.structured_evidence ?? args.evidenceJson),
+        workId,
+      );
+    } catch (error) {
+      return {
+        ok: false,
+        schema: 'work-item-evidence-append.v1',
+        workId,
+        violations: [{
+          code: 'invalid_structured_evidence',
+          severity: 'error',
+          message: error instanceof Error ? error.message : String(error),
+          fix: 'pass valid evidence-record.v1 JSON',
+        }],
+      };
+    }
+
+    const shapeViolations = validateStructuredEvidenceShape(structuredRecord);
+    const contractValidation = validateEvidenceForContract(structuredRecord, contract, workId);
+    const violations = [...shapeViolations, ...contractValidation.violations];
+    if (violations.some((violation) => violation.severity === 'error')) {
+      return {
+        ok: false,
+        schema: 'work-item-evidence-append.v1',
+        workId,
+        violations,
+      };
+    }
+
+    const jsonLine = formatStructuredEvidenceStorageLine(structuredRecord, workId);
+    const lines = [];
+    if (prose !== '') {
+      lines.push(prose);
+    } else if (structuredRecord.summary) {
+      lines.push(String(structuredRecord.summary));
+    }
+    if (!lines.includes(jsonLine)) {
+      lines.push(jsonLine);
+    }
+
+    return {
+      ok: true,
+      schema: 'work-item-evidence-append.v1',
+      workId,
+      lines,
+      structured: true,
+    };
+  }
+
+  if (prose === '') {
+    return {
+      ok: false,
+      schema: 'work-item-evidence-append.v1',
+      workId,
+      violations: [{
+        code: 'missing_evidence',
+        severity: 'error',
+        message: 'evidence or structuredEvidence is required',
+        fix: 'add_work_item_evidence with summary or structuredEvidence',
+      }],
+    };
+  }
+
+  if (strictTierA && !legacyEvidenceMatchesTierA([...(item.evidence ?? []), prose], contract)) {
+    return {
+      ok: false,
+      schema: 'work-item-evidence-append.v1',
+      workId,
+      violations: [{
+        code: 'structured_evidence_required',
+        severity: 'error',
+        message: 'Tier A gate task requires structuredEvidence or command-compatible prose',
+        fix: 'pass structuredEvidence { type, command, exitCode, status, taskId }',
+      }],
+      contract,
+    };
+  }
+
+  return {
+    ok: true,
+    schema: 'work-item-evidence-append.v1',
+    workId,
+    lines: [prose],
+    structured: false,
+  };
+}
+
+export function validateStructuredEvidenceDraftArray(records) {
+  if (records === undefined) {
+    return [];
+  }
+
+  if (!Array.isArray(records)) {
+    return ['structuredEvidence must be an array when provided'];
+  }
+
+  const errors = [];
+  records.forEach((record, index) => {
+    const violations = validateStructuredEvidenceShape(record);
+    for (const violation of violations) {
+      errors.push(`structuredEvidence[${index}].${violation.code}: ${violation.message}`);
+    }
+  });
+
+  return errors;
+}

package/vendor/src/ui/atoms/badge.mjs

@@ -3,6 +3,7 @@ import { escapeHtml, escapeHtmlAttr } from '../htmlEscape.mjs';
 const TONE_CLASS = {
   default: 'wg-badge--default',
   accent: 'wg-badge--accent',
+  warning: 'wg-badge--warning',
   muted: 'wg-badge--muted',
   danger: 'wg-badge--danger',
   ok: 'wg-badge--ok',
@@ -23,18 +24,80 @@ export function renderUiBadge(props = {}) {
 
 export const UI_BADGE_CSS = `
 .wg-badge {
-  display: inline-flex;
   align-items: center;
-  border-radius: 999px;
-  padding: 2px 8px;
+  border: 1px solid transparent;
+  border-radius: 3px;
+  display: inline-flex;
+  font-family: inherit;
   font-size: 11px;
-  font-weight: 600;
-  letter-spacing: 0.02em;
-  background: var(--panel-2);
-  color: var(--text);
-}
-.wg-badge--accent { background: var(--accent-soft); color: var(--accent); }
-.wg-badge--muted { background: var(--panel-2); color: var(--muted); }
-.wg-badge--danger { background: rgba(var(--ui-danger-rgb, 241 76 76), 0.18); color: rgb(var(--ui-danger-rgb, 241 76 76)); }
-.wg-badge--ok { background: rgba(106, 153, 85, 0.2); color: var(--ok); }
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  line-height: 1.2;
+  max-width: 130px;
+  overflow: hidden;
+  padding: 2px 4px;
+  text-overflow: ellipsis;
+  text-transform: uppercase;
+  white-space: nowrap;
+}
+.wg-badge--default {
+  background: #dfe1e6;
+  border-color: #c1c7d0;
+  color: #44546f;
+}
+.wg-badge--accent {
+  background: #deebff;
+  border-color: #85b8ff;
+  color: #0747a6;
+}
+.wg-badge--warning {
+  background: #fff0b3;
+  border-color: #f5cd47;
+  color: #172b4d;
+}
+.wg-badge--muted {
+  background: #dfd8fd;
+  border-color: #b8acf6;
+  color: #403294;
+}
+.wg-badge--danger {
+  background: #ffd2cc;
+  border-color: #ff9c8f;
+  color: #ae2a19;
+}
+.wg-badge--ok {
+  background: #baf3db;
+  border-color: #7ee2b8;
+  color: #216e4e;
+}
+body[data-theme="dark"] .wg-badge--default {
+  background: #738496;
+  border-color: #8696a7;
+  color: #161a1d;
+}
+body[data-theme="dark"] .wg-badge--accent {
+  background: #09326c;
+  border-color: #0055cc;
+  color: #cce0ff;
+}
+body[data-theme="dark"] .wg-badge--warning {
+  background: #533f04;
+  border-color: #7f5f01;
+  color: #fff0b3;
+}
+body[data-theme="dark"] .wg-badge--muted {
+  background: #352c63;
+  border-color: #5e4db2;
+  color: #dfd8fd;
+}
+body[data-theme="dark"] .wg-badge--danger {
+  background: #601e16;
+  border-color: #ae2a19;
+  color: #ffd2cc;
+}
+body[data-theme="dark"] .wg-badge--ok {
+  background: #164b35;
+  border-color: #216e4e;
+  color: #baf3db;
+}
 `;

package/vendor/src/ui/atoms/badgeClient.mjs

@@ -16,6 +16,7 @@ export function renderClientUiBadge(props = {}) {
   const TONE_CLASS = {
     default: 'wg-badge--default',
     accent: 'wg-badge--accent',
+    warning: 'wg-badge--warning',
     muted: 'wg-badge--muted',
     danger: 'wg-badge--danger',
     ok: 'wg-badge--ok',

package/vendor/src/ui/backlogShellButtons.mjs

@@ -1,7 +1,15 @@
+import { escapeHtml } from './htmlEscape.mjs';
 import { renderUiButton } from './atoms/button.mjs';
 import { renderUiSelect } from './atoms/select.mjs';
+import { renderNavViewIcon, renderThemeIcon } from './iconAssets.mjs';
 import { renderUiTabsGroup } from './molecules/tabs.mjs';
 
+function renderNavTabLabelHtml(view, label) {
+  const icon = renderNavViewIcon(view);
+  if (!icon) return escapeHtml(label);
+  return `${icon}<span class="nav-tab-label">${escapeHtml(label)}</span>`;
+}
+
 /**
  * Sidebar nav tab (Gripe DS unstyled shell — keeps .nav-tab CSS).
  * @param {{ view: string, label: string, selected?: boolean, disabled?: boolean }} props
@@ -10,7 +18,8 @@ export function renderNavTab({ view, label, selected = false, disabled = false }
   return renderUiButton({
     unstyled: true,
     className: 'nav-tab',
-    label,
+    labelHtml: renderNavTabLabelHtml(view, label),
+    ariaLabel: label,
     disabled,
     attrs: {
       'data-view': view,
@@ -19,16 +28,59 @@ export function renderNavTab({ view, label, selected = false, disabled = false }
   });
 }
 
-export function renderThemeToggleButton() {
+export function renderSettingsNavTab({ label = 'Настройки', selected = false }) {
+  return renderUiButton({
+    unstyled: true,
+    className: 'nav-tab nav-tab-settings',
+    labelHtml: renderNavTabLabelHtml('settings', label),
+    ariaLabel: label,
+    testId: 'sidebar-settings-nav',
+    attrs: {
+      'data-view': 'settings',
+      'aria-selected': selected ? 'true' : 'false',
+    },
+  });
+}
+
+export function renderHeaderThemeToggleButton({ ariaLabel = 'Переключить тему' } = {}) {
   return renderUiButton({
     unstyled: true,
     id: 'theme-toggle',
-    className: 'theme-toggle',
-    label: 'Тёмная тема',
-    attrs: { 'aria-pressed': 'false' },
+    className: 'header-theme-toggle',
+    ariaLabel,
+    ariaPressed: false,
+    testId: 'header-theme-toggle',
+    labelHtml: `<span class="header-theme-toggle-inner">${renderThemeIcon('moon')}</span>`,
   });
 }
 
+/** @deprecated footer full-width button — use renderHeaderThemeToggleButton */
+export function renderThemeToggleButton() {
+  return renderHeaderThemeToggleButton();
+}
+
+/**
+ * @param {{ locale: string, t: (key: string) => string }} props
+ */
+export function renderSettingsLocaleOptions({ locale, t }) {
+  const options = [
+    { id: 'ru', label: t('settings.language.ru') },
+    { id: 'en', label: t('settings.language.en') },
+  ];
+  return options.map(({ id, label }) => renderUiButton({
+    variant: 'secondary',
+    size: 'sm',
+    id: `settings-locale-${id}`,
+    className: locale === id ? 'is-active' : '',
+    label,
+    testId: id === 'ru' ? 'settings-locale-ru' : undefined,
+    attrs: {
+      'data-settings-locale': id,
+      'aria-pressed': locale === id ? 'true' : 'false',
+    },
+  })).join('\n                ');
+}
+
 export function renderDetailCloseButton() {
   return renderUiButton({
     unstyled: true,
@@ -175,7 +227,7 @@ export function renderAnalyticsSubtabsShell() {
   });
 }
 
-export function renderWorkflowSubtabsShell() {
+export function renderWorkflowSubtabsShell(labels = {}) {
   return renderUiTabsGroup({
     className: 'workflow-subtabs',
     testId: 'workflow-subtabs',
@@ -183,7 +235,7 @@ export function renderWorkflowSubtabsShell() {
     tabs: [
       {
         id: 'backlog',
-        label: 'Бэклог',
+        label: labels.backlog ?? 'Бэклог',
         selected: true,
         count: 0,
         elementId: 'workflow-tab-backlog',
@@ -192,7 +244,7 @@ export function renderWorkflowSubtabsShell() {
       },
       {
         id: 'archive',
-        label: 'Архив',
+        label: labels.archive ?? 'Архив',
         count: 0,
         elementId: 'workflow-tab-archive',
         dataAttrKey: 'data-workflow-tab',

package/vendor/src/ui/i18n/resolveUiLocale.mjs

@@ -0,0 +1,60 @@
+export const UI_LOCALE_COOKIE = 'wg_locale';
+export const SUPPORTED_UI_LOCALES = ['en', 'ru', 'ps'];
+export const DEFAULT_UI_LOCALE = 'ru';
+
+export function normalizeUiLocale(value) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (normalized === 'en' || normalized.startsWith('en-')) return 'en';
+  if (normalized === 'ru' || normalized.startsWith('ru-')) return 'ru';
+  if (normalized === 'ps' || normalized.startsWith('ps-')) return 'ps';
+  return null;
+}
+
+export function parseCookieHeader(header) {
+  const cookies = Object.create(null);
+  if (!header) return cookies;
+  for (const part of String(header).split(';')) {
+    const index = part.indexOf('=');
+    if (index <= 0) continue;
+    const key = part.slice(0, index).trim();
+    const value = decodeURIComponent(part.slice(index + 1).trim());
+    cookies[key] = value;
+  }
+  return cookies;
+}
+
+export function negotiateUiLocaleFromAcceptLanguage(header) {
+  if (!header) return null;
+  const parts = String(header).split(',').map((entry) => {
+    const [tag, ...params] = entry.trim().split(';');
+    let q = 1;
+    for (const param of params) {
+      const match = param.trim().match(/^q=([0-9.]+)$/);
+      if (match) q = Number.parseFloat(match[1]);
+    }
+    return { tag: tag.trim(), q: Number.isFinite(q) ? q : 0 };
+  }).sort((left, right) => right.q - left.q);
+
+  for (const { tag } of parts) {
+    const locale = normalizeUiLocale(tag);
+    if (locale) return locale;
+  }
+  return null;
+}
+
+/**
+ * @param {{ cookieHeader?: string, acceptLanguage?: string, queryLocale?: string }} input
+ */
+export function resolveUiLocale(input = {}) {
+  const fromQuery = normalizeUiLocale(input.queryLocale);
+  if (fromQuery) return fromQuery;
+
+  const cookies = parseCookieHeader(input.cookieHeader);
+  const fromCookie = normalizeUiLocale(cookies[UI_LOCALE_COOKIE]);
+  if (fromCookie) return fromCookie;
+
+  const fromAccept = negotiateUiLocaleFromAcceptLanguage(input.acceptLanguage);
+  if (fromAccept) return fromAccept;
+
+  return DEFAULT_UI_LOCALE;
+}

package/vendor/src/ui/i18n/uiCatalog.mjs

@@ -0,0 +1,58 @@
+import { readFileSync } from 'node:fs';
+import { readFile as readFileAsync } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { DEFAULT_UI_LOCALE, SUPPORTED_UI_LOCALES, resolveUiLocale } from './resolveUiLocale.mjs';
+
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+const repoLocalesRoot = join(moduleDir, '../../../locales');
+
+function interpolate(template, params = {}) {
+  return String(template).replace(/\{(\w+)\}/g, (_, key) => (
+    params[key] != null ? String(params[key]) : `{${key}}`
+  ));
+}
+
+export async function loadUiCatalog(locale, options = {}) {
+  const normalized = SUPPORTED_UI_LOCALES.includes(locale) ? locale : DEFAULT_UI_LOCALE;
+  const root = options.localesRoot ?? repoLocalesRoot;
+  const path = join(root, normalized, 'ui.json');
+  const text = await readFileAsync(path, 'utf8');
+  const messages = JSON.parse(text);
+  return { locale: normalized, messages };
+}
+
+export function loadUiCatalogSync(locale, options = {}) {
+  const normalized = SUPPORTED_UI_LOCALES.includes(locale) ? locale : DEFAULT_UI_LOCALE;
+  const root = options.localesRoot ?? repoLocalesRoot;
+  const path = join(root, normalized, 'ui.json');
+  const messages = JSON.parse(readFileSync(path, 'utf8'));
+  return { locale: normalized, messages };
+}
+
+export function createUiTranslator(catalog) {
+  const messages = catalog?.messages ?? {};
+  const locale = catalog?.locale ?? DEFAULT_UI_LOCALE;
+
+  function t(key, params) {
+    const template = messages[key] ?? key;
+    return params ? interpolate(template, params) : template;
+  }
+
+  return { locale, t, messages };
+}
+
+export async function createUiTranslatorForRequest(input = {}, options = {}) {
+  const locale = resolveUiLocale(input);
+  const catalog = await loadUiCatalog(locale, options);
+  return createUiTranslator(catalog);
+}
+
+export function listUiCatalogKeys(catalogA, catalogB) {
+  const keysA = new Set(Object.keys(catalogA?.messages ?? {}));
+  const keysB = new Set(Object.keys(catalogB?.messages ?? {}));
+  const missingInB = [...keysA].filter((key) => !keysB.has(key)).sort();
+  const missingInA = [...keysB].filter((key) => !keysA.has(key)).sort();
+  return { missingInA, missingInB };
+}