@work-graph/cli 0.2.0

package/vendor/src/onebaseCliRunner.mjs

@@ -0,0 +1,145 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+
+export function resolveOnebaseCliBinary(env = process.env, options = {}) {
+  const fromEnv = String(env.ONEBASE_CLI ?? '').trim();
+  if (fromEnv !== '') {
+    return fromEnv;
+  }
+
+  const repoRoot = options.repoRoot ?? process.cwd();
+  const portableWin = resolve(repoRoot, '../onebase/onebase.exe');
+  const portableUnix = resolve(repoRoot, '../onebase/onebase');
+  if (process.platform === 'win32' && existsSync(portableWin)) {
+    return portableWin;
+  }
+  if (existsSync(portableUnix)) {
+    return portableUnix;
+  }
+
+  return 'onebase';
+}
+
+export function resolveDefaultOnebaseProjectRoot(options = {}) {
+  const fromEnv = String(options.env?.ONEBASE_PROJECT_ROOT ?? process.env.ONEBASE_PROJECT_ROOT ?? '').trim();
+  if (fromEnv !== '') {
+    return resolve(fromEnv);
+  }
+
+  if (options.projectRoot) {
+    return resolve(String(options.projectRoot));
+  }
+
+  return resolve(options.repoRoot ?? process.cwd(), '../onebase/examples/trade');
+}
+
+export function buildOnebaseProjectArgs(projectRoot) {
+  const root = String(projectRoot ?? '').trim();
+  return root === '' ? [] : ['--project', root];
+}
+
+export function runOnebaseCli(subcommand, extraArgs = [], options = {}) {
+  const spawnImpl = options.spawnSyncImpl ?? spawnSync;
+  const binary = resolveOnebaseCliBinary(options.env, { repoRoot: options.repoRoot });
+  const projectRoot = options.projectRoot ?? options.cwd;
+  const args = [
+    subcommand,
+    ...extraArgs,
+    ...buildOnebaseProjectArgs(projectRoot),
+  ];
+  const command = `${binary} ${args.join(' ')}`;
+
+  let spawnResult;
+  try {
+    spawnResult = spawnImpl(binary, args, {
+      cwd: options.cwd ?? projectRoot,
+      env: options.env ?? process.env,
+      encoding: 'utf8',
+      shell: false,
+      timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      exitCode: 1,
+      stdout: '',
+      stderr: message,
+      command,
+      args,
+      failureClass: message.includes('ENOENT') ? 'cli_missing' : 'cli_error',
+      message,
+    };
+  }
+
+  const exitCode = spawnResult.status ?? 1;
+  const stdout = String(spawnResult.stdout ?? '');
+  const stderr = String(spawnResult.stderr ?? '');
+  const combined = `${stdout}\n${stderr}`.toLowerCase();
+
+  if (spawnResult.error) {
+    const message = spawnResult.error.message;
+    return {
+      ok: false,
+      exitCode,
+      stdout,
+      stderr,
+      command,
+      args,
+      failureClass: message.includes('ENOENT') ? 'cli_missing' : 'cli_error',
+      message,
+    };
+  }
+
+  if (
+    exitCode !== 0
+    && (combined.includes('unknown command')
+      || combined.includes('not found')
+      || combined.includes('no such command'))
+  ) {
+    return {
+      ok: false,
+      exitCode,
+      stdout,
+      stderr,
+      command,
+      args,
+      failureClass: 'cli_command_unavailable',
+      message: `OneBase CLI subcommand "${subcommand}" is not available in this onebase build`,
+    };
+  }
+
+  return {
+    ok: exitCode === 0,
+    exitCode,
+    stdout,
+    stderr,
+    command,
+    args,
+    failureClass: exitCode === 0 ? undefined : 'cli_error',
+    message: exitCode === 0 ? undefined : stderr.trim() || stdout.trim() || `exit ${exitCode}`,
+  };
+}
+
+export function runOnebaseCheck(options = {}) {
+  return runOnebaseCli('check', [], options);
+}
+
+export function runOnebaseDescribeJson(options = {}) {
+  return runOnebaseCli('describe', ['--json'], options);
+}
+
+export function formatOnebaseCliResult(result) {
+  return JSON.stringify({
+    ok: result.ok,
+    exitCode: result.exitCode,
+    command: result.command,
+    failureClass: result.failureClass ?? null,
+    message: result.message ?? null,
+    stdout: result.stdout,
+    stderr: result.stderr,
+  }, null, 2);
+}

package/vendor/src/onebaseGrossProfitStaticVerify.mjs

@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptDir = fileURLToPath(new URL('.', import.meta.url));
+export const DEFAULT_ONEBASE_ROOT = path.resolve(scriptDir, '../../onebase');
+
+/**
+ * Static cross-repo checks mirroring ../onebase/internal/project/trade_gross_profit_test.go.
+ * Does not replace go test ./...; validates artifact content when Go is unavailable.
+ *
+ * @param {string} [onebaseRoot]
+ */
+export function verifyOnebaseGrossProfitWarehouseArtifacts(onebaseRoot = DEFAULT_ONEBASE_ROOT) {
+  const failures = [];
+  const checkedFiles = [];
+
+  const registerPath = path.join(onebaseRoot, 'examples/trade/registers/валовая_прибыль.yaml');
+  const postingPath = path.join(onebaseRoot, 'examples/trade/src/реализациятоваров.posting.os');
+  const reportPath = path.join(onebaseRoot, 'examples/trade/reports/валовая_прибыль.yaml');
+  const kpiPath = path.join(onebaseRoot, 'examples/trade/widgets/валовая_прибыль_kpi.yaml');
+
+  const register = readText(registerPath, failures, checkedFiles);
+  const posting = readText(postingPath, failures, checkedFiles);
+  const report = readText(reportPath, failures, checkedFiles);
+  const kpi = readText(kpiPath, failures, checkedFiles);
+
+  if (register) {
+    if (!hasYamlField(register, 'Номенклатура', 'reference:Номенклатура')) {
+      failures.push('register must keep Номенклатура dimension');
+    }
+    if (!hasYamlField(register, 'Склад', 'reference:Склад')) {
+      failures.push('register must include Склад dimension');
+    }
+  }
+
+  if (report) {
+    if (!hasReportParam(report, 'Склад', 'reference:Склад')) {
+      failures.push('report must expose Склад filter');
+    }
+    if (!report.includes('СГРУППИРОВАТЬ ПО Номенклатура, Склад')) {
+      failures.push('report must group by Номенклатура and Склад');
+    }
+    if (!report.includes('Склад = &Склад')) {
+      failures.push('report must filter by Склад');
+    }
+  }
+
+  if (kpi) {
+    if (kpi.includes('СГРУППИРОВАТЬ') || kpi.includes('Склад')) {
+      failures.push('gross-profit KPI must remain a total query');
+    }
+  }
+
+  if (posting && !posting.includes('ДвВП.Склад        = this.Склад')) {
+    failures.push('РеализацияТоваров gross-profit movement must set Склад');
+  }
+
+  const testPath = path.join(onebaseRoot, 'internal/project/trade_gross_profit_test.go');
+  const testSource = readText(testPath, failures, checkedFiles);
+  if (testSource && !testSource.includes('TestTradeGrossProfitWarehouseDimension')) {
+    failures.push('targeted trade_gross_profit_test.go must include warehouse dimension test');
+  }
+
+  return {
+    ok: failures.length === 0,
+    failures,
+    checkedFiles,
+    onebaseRoot,
+  };
+}
+
+/** @param {string} filePath @param {string[]} failures @param {string[]} checkedFiles */
+function readText(filePath, failures, checkedFiles) {
+  checkedFiles.push(filePath);
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch (error) {
+    failures.push(`missing or unreadable file: ${filePath} (${error.message})`);
+    return null;
+  }
+}
+
+/** @param {string} yaml @param {string} name @param {string} type */
+function hasYamlField(yaml, name, type) {
+  const block = yaml.match(/dimensions:[\s\S]*?(?=\nresources:|\n[a-z_]+:|$)/i);
+  if (!block) return false;
+  const lines = block[0];
+  return lines.includes(`name: ${name}`) && lines.includes(`type: ${type}`);
+}
+
+/** @param {string} yaml @param {string} name @param {string} type */
+function hasReportParam(yaml, name, type) {
+  const block = yaml.match(/params:[\s\S]*?(?=\nquery:|$)/i);
+  if (!block) return false;
+  const lines = block[0];
+  return lines.includes(`name: ${name}`) && lines.includes(`type: ${type}`);
+}

package/vendor/src/onebaseParityEvidenceSync.mjs

@@ -0,0 +1,88 @@
+import { writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { buildOneBaseMcpParityMatrix } from './onebaseWorkItemTemplate.mjs';
+import {
+  probeOnebaseCliCapabilities,
+  resolveDefaultCapabilitiesPath,
+} from './onebaseCliCapabilityProbe.mjs';
+
+const CAPABILITY_TO_CLI = {
+  metadata_scan: null,
+  describe_config: 'describe',
+  check_config: 'check',
+  ai_guide: 'ai-guide',
+  read_config_file: null,
+  rest_read: null,
+  dev_health: null,
+  deterministic_verify: null,
+};
+
+export function attachCliAvailabilityToParityRows(rows, probe) {
+  const commandMap = probe?.commands ?? {};
+
+  return rows.map((row) => {
+    const cliCommand = CAPABILITY_TO_CLI[row.capability] ?? null;
+    if (!cliCommand) {
+      return { ...row, cliAvailable: null };
+    }
+
+    return {
+      ...row,
+      cliAvailable: Boolean(commandMap[cliCommand]),
+      cliCommand,
+    };
+  });
+}
+
+export function buildOnebaseParityEvidencePayload(probe, options = {}) {
+  const baseMatrix = buildOneBaseMcpParityMatrix();
+  const rows = attachCliAvailabilityToParityRows(baseMatrix.rows, probe);
+
+  return {
+    schema: 'onebase.parity-evidence.v1',
+    probedAt: probe.probedAt,
+    binary: probe.binary,
+    cliProbe: probe,
+    parity: {
+      ...baseMatrix,
+      rows,
+    },
+    evidenceLine: formatParityEvidenceLine(probe),
+    projectRoot: options.projectRoot ?? null,
+  };
+}
+
+export function formatParityEvidenceLine(probe) {
+  const check = probe.commands?.check ? 'available' : 'missing';
+  const describe = probe.commands?.describe ? 'available' : 'missing';
+  const aiGuide = probe.commands?.['ai-guide'] ? 'available' : 'missing';
+  return `onebase CLI probe ${probe.probedAt}: binary=${probe.binary}; check=${check}; describe=${describe}; ai-guide=${aiGuide}`;
+}
+
+export async function syncOnebaseParityEvidence(options = {}) {
+  const repoRoot = options.repoRoot ?? process.cwd();
+  const probe = options.probe ?? probeOnebaseCliCapabilities({ repoRoot, ...options });
+  const payload = buildOnebaseParityEvidencePayload(probe, options);
+  const outputPath = resolve(repoRoot, options.outputPath ?? resolveDefaultCapabilitiesPath({ repoRoot }));
+
+  if (options.writeFile !== false) {
+    await writeFile(outputPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+  }
+
+  return {
+    ok: true,
+    outputPath,
+    payload,
+    probe,
+  };
+}
+
+export function readParityRowsWithCachedProbe(probePayload) {
+  const baseMatrix = buildOneBaseMcpParityMatrix();
+  if (!probePayload?.cliProbe) {
+    return baseMatrix.rows;
+  }
+
+  return attachCliAvailabilityToParityRows(baseMatrix.rows, probePayload.cliProbe);
+}

package/vendor/src/onebasePvrgGraphNodes.mjs

@@ -0,0 +1,257 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+
+import { resolveOnebaseMetadataScanRoot } from './onebaseCliCapabilityProbe.mjs';
+
+export const ONEBASE_PVRG_METADATA_DIRS = ['catalogs', 'documents', 'registers', 'inforegs', 'reports', 'constants'];
+const YAML_EXT = /\.(yaml|yml)$/iu;
+const POSTING_OS_EXT = /\.posting\.os$/iu;
+
+function normalizeRelPath(path) {
+  return String(path).replace(/\\/g, '/');
+}
+
+function inferOnebaseKindFromPath(relPath) {
+  const normalized = normalizeRelPath(relPath).toLowerCase();
+  for (const dir of ONEBASE_PVRG_METADATA_DIRS) {
+    if (normalized.includes(`/${dir}/`) || normalized.startsWith(`${dir}/`)) {
+      if (dir === 'catalogs') {
+        return 'catalog';
+      }
+      if (dir === 'documents') {
+        return 'document';
+      }
+      return dir.endsWith('s') ? dir.slice(0, -1) : dir;
+    }
+  }
+  return 'artifact';
+}
+
+export function parseOnebaseYamlSummary(text, relPath) {
+  const nameMatch = String(text ?? '').match(/^name:\s*(.+)$/mu);
+  if (!nameMatch) {
+    return null;
+  }
+
+  const name = nameMatch[1].trim();
+  const posting = /^posting:\s*true/mu.test(text);
+
+  return {
+    kind: inferOnebaseKindFromPath(relPath),
+    name,
+    posting,
+    yamlPath: normalizeRelPath(relPath),
+  };
+}
+
+function listFilesRecursive(dir, prefix = '') {
+  const entries = [];
+  if (!existsSync(dir)) {
+    return entries;
+  }
+
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    const abs = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      entries.push(...listFilesRecursive(abs, rel));
+      continue;
+    }
+    entries.push({ abs, rel: normalizeRelPath(rel) });
+  }
+
+  return entries;
+}
+
+function findPostingScriptPath(projectRoot, documentName) {
+  const srcDir = join(projectRoot, 'src');
+  if (!existsSync(srcDir)) {
+    return null;
+  }
+
+  const normalizedDocumentName = String(documentName).toLowerCase();
+  for (const file of listFilesRecursive(srcDir, 'src')) {
+    if (!POSTING_OS_EXT.test(file.rel)) {
+      continue;
+    }
+
+    const baseName = file.rel.split('/').pop()?.replace(/\.posting\.os$/iu, '') ?? '';
+    if (baseName.toLowerCase() === normalizedDocumentName) {
+      return file.rel;
+    }
+  }
+
+  return null;
+}
+
+export function scanOnebaseMetadataSync(projectRoot, options = {}) {
+  const root = resolve(projectRoot ?? process.cwd());
+  if (!existsSync(root)) {
+    return [];
+  }
+
+  const entries = [];
+  for (const file of listFilesRecursive(root)) {
+    if (!YAML_EXT.test(file.rel)) {
+      continue;
+    }
+
+    if (!ONEBASE_PVRG_METADATA_DIRS.some((dir) => file.rel.includes(`/${dir}/`) || file.rel.startsWith(`${dir}/`))) {
+      continue;
+    }
+
+    const summary = parseOnebaseYamlSummary(readFileSync(file.abs, 'utf8'), file.rel);
+    if (!summary) {
+      continue;
+    }
+
+    const postingOsPath = summary.kind === 'document' && summary.posting
+      ? findPostingScriptPath(root, summary.name)
+      : null;
+
+    entries.push({
+      ...summary,
+      traceId: `onebase:${summary.kind}:${summary.name}`,
+      ...(postingOsPath ? { postingOsPath } : {}),
+    });
+  }
+
+  return entries.sort((left, right) => left.yamlPath.localeCompare(right.yamlPath, 'en', { sensitivity: 'variant' }));
+}
+
+export function buildOnebaseArtifactNodeId(kind, name) {
+  return `onebase:${kind}:${name}`;
+}
+
+export function buildOnebasePvrgGraphNodes(metadataEntries = [], options = {}) {
+  const nodeById = new Map();
+  const edges = [];
+  const edgeKeys = new Set();
+
+  function ensureNode(node) {
+    if (!nodeById.has(node.id)) {
+      nodeById.set(node.id, node);
+    }
+    return nodeById.get(node.id);
+  }
+
+  function addEdge(edge) {
+    const key = `${edge.from}->${edge.to}:${edge.type}`;
+    if (edgeKeys.has(key)) {
+      return;
+    }
+    edgeKeys.add(key);
+    edges.push(edge);
+  }
+
+  for (const entry of metadataEntries) {
+    const artifactNode = ensureNode({
+      id: buildOnebaseArtifactNodeId(entry.kind, entry.name),
+      kind: 'onebase_artifact',
+      onebaseKind: entry.kind,
+      title: entry.name,
+      subtitle: entry.kind,
+      path: entry.yamlPath,
+      traceId: entry.traceId,
+      posting: entry.posting === true,
+    });
+
+    if (entry.postingOsPath) {
+      const scriptNode = ensureNode({
+        id: buildOnebaseArtifactNodeId('posting_script', entry.name),
+        kind: 'onebase_artifact',
+        onebaseKind: 'posting_script',
+        title: `${entry.name}.posting`,
+        subtitle: 'posting_script',
+        path: entry.postingOsPath,
+        traceId: `onebase:posting_script:${entry.name}`,
+        posting: true,
+      });
+      addEdge({
+        from: artifactNode.id,
+        to: scriptNode.id,
+        type: 'onebase_posting',
+      });
+    }
+  }
+
+  const nodes = [...nodeById.values()].sort((left, right) => left.id.localeCompare(right.id, 'en', { sensitivity: 'variant' }));
+  const sortedEdges = edges.sort((left, right) =>
+    `${left.from}\0${left.to}\0${left.type}`.localeCompare(`${right.from}\0${right.to}\0${right.type}`, 'en', { sensitivity: 'variant' }),
+  );
+
+  return {
+    schema: 'onebase.pvrg_graph_nodes.v1',
+    projectRoot: options.projectRoot ? normalizeRelPath(relative(options.repoRoot ?? process.cwd(), options.projectRoot)) : null,
+    nodes,
+    edges: sortedEdges,
+    counts: {
+      nodes: nodes.length,
+      edges: sortedEdges.length,
+      documents: nodes.filter((node) => node.onebaseKind === 'document').length,
+      catalogs: nodes.filter((node) => node.onebaseKind === 'catalog').length,
+      postingScripts: nodes.filter((node) => node.onebaseKind === 'posting_script').length,
+    },
+  };
+}
+
+export function buildOnebasePvrgGraphFromProjectRoot(options = {}) {
+  const repoRoot = options.repoRoot ?? process.cwd();
+  const projectRoot = options.projectRoot ?? resolveOnebaseMetadataScanRoot({ repoRoot });
+  if (!projectRoot) {
+    return buildOnebasePvrgGraphNodes([], { repoRoot, projectRoot: null });
+  }
+
+  const metadataEntries = scanOnebaseMetadataSync(projectRoot);
+  return buildOnebasePvrgGraphNodes(metadataEntries, { repoRoot, projectRoot });
+}
+
+export function mergeOnebaseGraphIntoBlockL2Graph(l2Graph, onebaseGraph, options = {}) {
+  if (!onebaseGraph || onebaseGraph.nodes.length === 0) {
+    return l2Graph;
+  }
+
+  const containerId = options.containerId ?? 'container:onebase-domain';
+  const maxNodes = options.maxNodes ?? l2Graph.counts?.nodes ?? Number.MAX_SAFE_INTEGER;
+  const mergedNodes = [...l2Graph.nodes];
+  const mergedEdges = [...l2Graph.edges];
+  const visibleIds = new Set(mergedNodes.map((node) => node.id));
+
+  for (const node of onebaseGraph.nodes) {
+    if (mergedNodes.length >= maxNodes) {
+      break;
+    }
+    mergedNodes.push(node);
+    visibleIds.add(node.id);
+    mergedEdges.push({
+      from: containerId,
+      to: node.id,
+      type: 'hosts_onebase',
+    });
+  }
+
+  for (const edge of onebaseGraph.edges) {
+    if (visibleIds.has(edge.from) && visibleIds.has(edge.to)) {
+      mergedEdges.push(edge);
+    }
+  }
+
+  const hiddenCount = Math.max(0, (l2Graph.hiddenCount ?? 0) + Math.max(0, onebaseGraph.nodes.length - (maxNodes - l2Graph.nodes.length)));
+
+  return {
+    ...l2Graph,
+    nodes: mergedNodes,
+    edges: mergedEdges.sort((left, right) =>
+      `${left.from}\0${left.to}\0${left.type}`.localeCompare(`${right.from}\0${right.to}\0${right.type}`, 'en', { sensitivity: 'variant' }),
+    ),
+    onebaseMerged: true,
+    hiddenCount,
+    capped: hiddenCount > 0,
+    counts: {
+      ...l2Graph.counts,
+      nodes: mergedNodes.length,
+      edges: mergedEdges.length,
+      onebaseArtifacts: onebaseGraph.nodes.length,
+    },
+  };
+}