@work-graph/cli 0.2.0

package/vendor/src/languageAdapters/onebaseOsAdapter.mjs

@@ -0,0 +1,55 @@
+import { buildFileFactsEnvelope, createCapabilities } from './shared.mjs';
+
+export const onebaseOsAdapter = {
+  id: 'onebase-os-v1',
+  languageId: 'onebase-os',
+  extensions: ['.os'],
+  artifactProfiles: ['onebase-posting-script'],
+  capabilities: createCapabilities({
+    syntax: 'structured',
+    symbols: true,
+    domainMetadata: true,
+    semanticChunks: true,
+    verificationHints: true,
+  }),
+  confidence: 'medium',
+  fallback: 'plaintext-v1',
+  owner: 'work-graph',
+};
+
+const PROCEDURE_PATTERN = /(?:Процедура|Procedure)\s+([\wА-Яа-яЁё]+)\s*\(/gu;
+const MOVEMENT_PATTERN = /Движения\.([\wА-Яа-яЁё]+)/gu;
+const FIELD_REF_PATTERN = /(?:Строка|this)\.([\wА-Яа-яЁё]+)/gu;
+
+export function extractOnebaseOsFacts(content, context = {}) {
+  const filePath = context.filePath ?? '';
+  const text = String(content);
+  const procedures = [...text.matchAll(PROCEDURE_PATTERN)].map((match) => match[1]);
+  const registers = [...new Set([...text.matchAll(MOVEMENT_PATTERN)].map((match) => match[1]))];
+  const documentFields = [...new Set([...text.matchAll(FIELD_REF_PATTERN)].map((match) => match[1]))];
+
+  const symbols = procedures.map((name) => ({ kind: 'procedure', name }));
+  const domainMetadata = {
+    postingScript: true,
+    procedures,
+    registers,
+    documentFields,
+    clearsMovements: /Движения\.[\wА-Яа-яЁё]+\.Очистить\(\)/u.test(text),
+  };
+
+  const testHints = [{
+    kind: 'onebase-posting',
+    commandHint: 'npm run test:optional:onebase',
+  }];
+
+  return buildFileFactsEnvelope(onebaseOsAdapter, filePath, {
+    symbols,
+    domainMetadata,
+    testHints,
+    chunks: procedures.map((name) => ({
+      ref: `procedure:${name}`,
+      kind: 'onebase-procedure',
+      text: name,
+    })),
+  });
+}

package/vendor/src/languageAdapters/plaintextAdapter.mjs

@@ -0,0 +1,36 @@
+import {
+  basenameFromPath,
+  buildFileFactsEnvelope,
+  createCapabilities,
+  lexicalChunks,
+} from './shared.mjs';
+
+export const plaintextAdapter = {
+  id: 'plaintext-v1',
+  languageId: 'plaintext',
+  extensions: ['*'],
+  artifactProfiles: ['generic-file'],
+  capabilities: createCapabilities({
+    syntax: 'lexical',
+    semanticChunks: true,
+  }),
+  confidence: 'low',
+  fallback: null,
+  owner: 'work-graph',
+};
+
+export function extractPlaintextFacts(content, context = {}) {
+  const filePath = context.filePath ?? '';
+  const extension = context.extension ?? '';
+
+  return buildFileFactsEnvelope(plaintextAdapter, filePath, {
+    chunks: lexicalChunks(content),
+    domainMetadata: {
+      extension,
+      basename: basenameFromPath(filePath),
+      byteLength: Buffer.byteLength(String(content), 'utf8'),
+    },
+  }, {
+    confidence: 'low',
+  });
+}

package/vendor/src/languageAdapters/shared.mjs

@@ -0,0 +1,68 @@
+export const LANGUAGE_FILE_FACTS_SCHEMA = 'workgraph.language-file-facts.v1';
+
+export function createCapabilities(partial = {}) {
+  return {
+    syntax: partial.syntax ?? 'none',
+    symbols: Boolean(partial.symbols),
+    imports: Boolean(partial.imports),
+    tests: Boolean(partial.tests),
+    semanticChunks: Boolean(partial.semanticChunks),
+    domainMetadata: Boolean(partial.domainMetadata),
+    traceLinks: Boolean(partial.traceLinks),
+    verificationHints: Boolean(partial.verificationHints),
+  };
+}
+
+export function buildFileFactsEnvelope(adapter, filePath, payload, options = {}) {
+  return {
+    schema: LANGUAGE_FILE_FACTS_SCHEMA,
+    filePath,
+    languageId: adapter.languageId,
+    adapterId: adapter.id,
+    status: options.status ?? 'ok',
+    confidence: options.confidence ?? adapter.confidence,
+    capabilities: { ...adapter.capabilities },
+    symbols: payload.symbols ?? [],
+    imports: payload.imports ?? [],
+    chunks: payload.chunks ?? [],
+    domainMetadata: payload.domainMetadata ?? {},
+    testHints: payload.testHints ?? [],
+    traceRefs: payload.traceRefs ?? [],
+    diagnostics: payload.diagnostics ?? [],
+  };
+}
+
+export function lexicalChunks(content, options = {}) {
+  const lines = String(content).split(/\r?\n/u);
+  const maxLines = options.maxLines ?? 40;
+  const chunks = [];
+
+  for (let index = 0; index < lines.length; index += maxLines) {
+    const slice = lines.slice(index, index + maxLines);
+    chunks.push({
+      ref: `lines:${index + 1}-${index + slice.length}`,
+      kind: 'lexical',
+      text: slice.join('\n'),
+    });
+  }
+
+  if (chunks.length === 0) {
+    chunks.push({ ref: 'lines:1-1', kind: 'lexical', text: '' });
+  }
+
+  return chunks;
+}
+
+export function extensionFromPath(filePath) {
+  const normalized = String(filePath ?? '').replace(/\\/gu, '/');
+  const index = normalized.lastIndexOf('.');
+  if (index === -1) {
+    return '';
+  }
+
+  return normalized.slice(index).toLowerCase();
+}
+
+export function basenameFromPath(filePath) {
+  return String(filePath ?? '').replace(/\\/gu, '/').split('/').pop() ?? '';
+}

package/vendor/src/languageAdapters/stepAdapter.mjs

@@ -0,0 +1,81 @@
+import { parseStepAtomDrafts } from '../stepAtomFormatter.mjs';
+import { lintBvcFilePath } from '../bvcFileFormat.mjs';
+import { buildFileFactsEnvelope, createCapabilities, lexicalChunks } from './shared.mjs';
+
+export const stepAdapter = {
+  id: 'bvc-v1',
+  languageId: 'bvc',
+  legacyLanguageIds: ['step'],
+  extensions: ['.bvc', '.bvc'],
+  artifactProfiles: ['bvc-atom', 'step-atom', 'work-item', 'protocol'],
+  capabilities: createCapabilities({
+    syntax: 'structured',
+    symbols: true,
+    semanticChunks: true,
+    traceLinks: true,
+  }),
+  confidence: 'high',
+  fallback: 'plaintext-v1',
+  owner: 'work-graph',
+};
+
+export function extractStepFacts(content, context = {}) {
+  const filePath = context.filePath ?? '';
+  const parsedAtoms = parseStepAtomDrafts(String(content));
+  const pathLints = filePath ? lintBvcFilePath(filePath) : [];
+  const symbols = [];
+  const traceRefs = [];
+  const chunks = [];
+
+  for (const parsed of parsedAtoms) {
+    const labels = parsed.draft.labels ?? {};
+    symbols.push({
+      kind: labels['atom.profile'] ?? 'bvc-atom',
+      name: parsed.draft.name,
+      profile: parsed.draft.profile,
+      lang: parsed.draft.lang ?? null,
+    });
+
+    if (labels['work.id']) {
+      traceRefs.push({ kind: 'work.id', value: labels['work.id'] });
+    }
+
+    if (labels['protocol.id']) {
+      traceRefs.push({ kind: 'protocol.id', value: labels['protocol.id'] });
+    }
+
+    if (labels['rule.id']) {
+      traceRefs.push({ kind: 'rule.id', value: labels['rule.id'] });
+    }
+
+    chunks.push({
+      ref: `atom:${parsed.draft.name}`,
+      kind: 'step-atom',
+      text: [
+        parsed.draft.basis.join(' '),
+        parsed.draft.vector.join(' '),
+        parsed.draft.goal.join(' '),
+      ].filter(Boolean).join('\n'),
+    });
+  }
+
+  if (chunks.length === 0) {
+    chunks.push(...lexicalChunks(content, { maxLines: 24 }));
+  }
+
+  const diagnostics = [
+    ...pathLints.map((lint) => `${lint.code}: ${lint.message}`),
+    ...parsedAtoms.flatMap((parsed) => parsed.errors ?? []),
+    ...parsedAtoms.flatMap((parsed) => (parsed.lints ?? []).map((lint) => `${lint.code}: ${lint.message}`)),
+  ];
+
+  return buildFileFactsEnvelope(stepAdapter, filePath, {
+    symbols,
+    traceRefs,
+    chunks,
+    diagnostics,
+  }, {
+    status: diagnostics.length > 0 ? 'degraded' : 'ok',
+    confidence: diagnostics.length > 0 ? 'medium' : 'high',
+  });
+}

package/vendor/src/lintPlanWorkAlignment.mjs

@@ -0,0 +1,136 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { readWorkItemsFromRepo } from './intentTreeWorkItems.mjs';
+
+const PLAN_GLOB_PREFIX = 'plan-';
+const WORK_ID_IN_LINE = /`([a-z][a-z0-9-]*)`/i;
+const UNCHECKED_TODO = /^-\s+\[\s\]\s+/;
+
+const PIPELINE_ORDER = ['intake', 'analyzed', 'decided', 'ready', 'executing', 'closed'];
+
+export function lintPlanTodoLines(planText, filePath) {
+  const issues = [];
+  const lines = planText.split(/\r?\n/);
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+
+    if (!UNCHECKED_TODO.test(line)) {
+      continue;
+    }
+
+    if (WORK_ID_IN_LINE.test(line)) {
+      continue;
+    }
+
+    issues.push({
+      code: 'plan_todo_missing_work_id',
+      severity: 'warning',
+      filePath,
+      line: index + 1,
+      message: `unchecked todo без work.id в backticks: ${line.trim()}`,
+    });
+  }
+
+  return issues;
+}
+
+export function lintWorkItemDoingBeforeReady(workItems) {
+  const issues = [];
+
+  for (const item of workItems) {
+    const status = item.status ?? item.labels?.['work.status'];
+    const stage = item.labels?.['work.pipeline_stage'] ?? inferStageFromItem(item);
+
+    if (status !== 'doing') {
+      continue;
+    }
+
+    if (!stage || stage === 'executing' || stage === 'closed') {
+      continue;
+    }
+
+    const stageIndex = PIPELINE_ORDER.indexOf(stage);
+    const readyIndex = PIPELINE_ORDER.indexOf('ready');
+
+    if (stageIndex !== -1 && stageIndex < readyIndex) {
+      issues.push({
+        code: 'work_doing_before_ready',
+        severity: 'warning',
+        workId: item.id,
+        message: `work.status=doing при work.pipeline_stage=${stage} (< ready)`,
+      });
+    }
+  }
+
+  return issues;
+}
+
+function inferStageFromItem(item) {
+  if (item.labels?.['work.pipeline_stage']) {
+    return item.labels['work.pipeline_stage'];
+  }
+
+  if (item.decisionVerdict) {
+    return 'decided';
+  }
+
+  if (item.analysis) {
+    return 'analyzed';
+  }
+
+  return 'intake';
+}
+
+export async function lintPlanWorkAlignment(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const docsDir = join(cwd, 'docs');
+  const issues = [];
+
+  let planFiles = [];
+
+  try {
+    const entries = await readdir(docsDir);
+    planFiles = entries
+      .filter((name) => name.startsWith(PLAN_GLOB_PREFIX) && name.endsWith('.md'))
+      .map((name) => join('docs', name));
+  } catch {
+    planFiles = [];
+  }
+
+  for (const filePath of planFiles) {
+    const text = await readFile(join(cwd, filePath), 'utf8');
+    issues.push(...lintPlanTodoLines(text, filePath));
+  }
+
+  const workItems = options.workItems ?? await readWorkItemsFromRepo({ cwd });
+  issues.push(...lintWorkItemDoingBeforeReady(workItems));
+
+  const errors = issues.filter((issue) => issue.severity === 'error');
+  const warnings = issues.filter((issue) => issue.severity === 'warning');
+
+  return {
+    schema: 'workgraph.lint-plan-work-alignment.v1',
+    ok: errors.length === 0,
+    issueCount: issues.length,
+    errors,
+    warnings,
+    issues,
+  };
+}
+
+export function formatPlanWorkAlignmentReport(report) {
+  const lines = [
+    `plan-work alignment: ${report.ok ? 'ok' : 'fail'} (${report.errors.length} errors, ${report.warnings.length} warnings)`,
+  ];
+
+  for (const issue of report.issues) {
+    const location = issue.filePath
+      ? `${issue.filePath}:${issue.line ?? '?'}`
+      : issue.workId ?? '?';
+    lines.push(`  [${issue.severity}] ${issue.code} @ ${location} — ${issue.message}`);
+  }
+
+  return lines.join('\n');
+}

package/vendor/src/loopHintRepeatToolEval.mjs

@@ -0,0 +1,153 @@
+import { resolveOpenAiProviderEnv } from './agentWorkerOpenAiProvider.mjs';
+import {
+  createAgentToolLoopTracker,
+  formatAgentToolDuplicateInvocationLoopHint,
+} from './agentToolLoopGuard.mjs';
+
+export const LOOP_HINT_REPEAT_TOOL_EVAL_SCHEMA = 'workgraph.loop-hint-repeat-tool.eval.v1';
+
+const STOP_KEYWORDS = [
+  'loop_hint',
+  'loop hint',
+  'change strategy',
+  'different tool',
+  'stop repeating',
+  'не повторя',
+  'смени стратег',
+  'другой инструмент',
+  'зацикл',
+];
+
+export function buildRepeatToolCallFixture() {
+  return {
+    toolName: 'get_work_item',
+    args: { workId: 'ready-eval' },
+    repeats: 3,
+  };
+}
+
+export function evaluateRepeatToolCallLoopDeterministic(fixture = buildRepeatToolCallFixture()) {
+  const tracker = createAgentToolLoopTracker();
+  let lastRecord = null;
+
+  for (let index = 0; index < fixture.repeats; index += 1) {
+    lastRecord = tracker.record(fixture.toolName, fixture.args);
+  }
+
+  return {
+    ok: lastRecord?.loopAborted === true && String(lastRecord.loopHint ?? '').includes('LOOP_HINT'),
+    lastRecord,
+    counts: tracker.snapshot(),
+  };
+}
+
+export function buildLoopHintPrompt(loopHintText) {
+  return [
+    'You are simulating a WorkGraph MCP agent workflow.',
+    'The tool executor returned LOOP_HINT because you repeated the same tool call.',
+    'Respond in plain text. Acknowledge LOOP_HINT and stop repeating the same tool with the same arguments.',
+    'Do not call get_work_item again in this response.',
+    '',
+    'Tool result:',
+    loopHintText,
+  ].join('\n');
+}
+
+export function evaluateLoopHintModelResponse(text, options = {}) {
+  const body = String(text ?? '');
+  const lower = body.toLowerCase();
+  const repeatedSameTool = /\bget_work_item\b/u.test(body)
+    && /\bready-eval\b/u.test(body)
+    && /\b(call|invoke|claim|execute|вызов)/iu.test(body);
+  const hasStopSignal = STOP_KEYWORDS.some((keyword) => lower.includes(keyword));
+
+  return {
+    ok: hasStopSignal && !repeatedSameTool,
+    hasStopSignal,
+    repeatedSameTool,
+  };
+}
+
+export async function fetchLoopHintModelResponse(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 LOOP_HINT: stop repeating identical tool calls.' },
+        { 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 runLoopHintRepeatToolEval(options = {}) {
+  const fixture = options.fixture ?? buildRepeatToolCallFixture();
+  const deterministic = evaluateRepeatToolCallLoopDeterministic(fixture);
+
+  if (!deterministic.ok) {
+    return {
+      schema: LOOP_HINT_REPEAT_TOOL_EVAL_SCHEMA,
+      ok: false,
+      failureClass: 'code_failure',
+      deterministic,
+      live: null,
+    };
+  }
+
+  const env = resolveOpenAiProviderEnv(options);
+  if (env.liveEnabled !== true && options.requireLive !== false) {
+    return {
+      schema: LOOP_HINT_REPEAT_TOOL_EVAL_SCHEMA,
+      ok: true,
+      failureClass: 'skipped',
+      reason: 'IOHASC_E2E_REAL_LLM is not set; deterministic LOOP_HINT guard verified',
+      deterministic,
+      live: null,
+      rubric: {
+        deterministic: 'same tool+args >= threshold → loopAborted + LOOP_HINT text',
+        liveOptional: 'model acknowledges LOOP_HINT and does not repeat identical tool call',
+      },
+    };
+  }
+
+  const loopHintText = formatAgentToolDuplicateInvocationLoopHint(fixture.toolName, deterministic.lastRecord.loopStreak);
+  const prompt = buildLoopHintPrompt(loopHintText);
+  const responseText = await fetchLoopHintModelResponse(prompt, options);
+  const live = evaluateLoopHintModelResponse(responseText);
+
+  return {
+    schema: LOOP_HINT_REPEAT_TOOL_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,
+    },
+    rubric: {
+      deterministic: 'same tool+args >= threshold → loopAborted + LOOP_HINT text',
+      liveOptional: 'model acknowledges LOOP_HINT and does not repeat identical tool call',
+    },
+  };
+}