@work-graph/cli 0.2.0

package/vendor/src/workGraphDaemonWatch.mjs

@@ -0,0 +1,157 @@
+import { pathToFileURL } from 'node:url';
+
+import {
+  appendDaemonAuditJournal,
+  runWorkGraphDaemonTickFromBacklogFile,
+} from './workGraphDaemonTick.mjs';
+
+export const DAEMON_WATCH_OUTPUT_SCHEMA = 'workgraph.daemon.watch.output.v1';
+
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+export async function runWorkGraphDaemonWatch(options = {}) {
+  const maxTicks = Number.isInteger(options.maxTicks) && options.maxTicks > 0 ? options.maxTicks : 2;
+  const intervalMs = Number.isInteger(options.intervalMs) && options.intervalMs >= 0 ? options.intervalMs : 50;
+  const maxDurationMs = Number.isInteger(options.maxDurationMs) && options.maxDurationMs > 0 ? options.maxDurationMs : 5000;
+  const writeJournal = options.writeJournal !== false;
+  const dryRun = options.dryRun !== false;
+  const startedAt = Date.now();
+  const results = [];
+
+  for (let index = 0; index < maxTicks; index += 1) {
+    if (Date.now() - startedAt >= maxDurationMs) {
+      break;
+    }
+
+    const tickId = options.tickIdPrefix
+      ? `${options.tickIdPrefix}-${index + 1}`
+      : `watch-tick-${index + 1}`;
+
+    const result = await runWorkGraphDaemonTickFromBacklogFile({
+      ...options,
+      tickId,
+      runId: options.runId ?? `watch-run-${index + 1}`,
+      schedulerPolicy: {
+        dryRun,
+        paused: false,
+        ...(options.schedulerPolicy ?? {}),
+      },
+    });
+
+    if (writeJournal && result.auditRecord) {
+      await appendDaemonAuditJournal(result.auditRecord, options);
+    }
+
+    results.push({
+      tickId: result.tickId,
+      ok: result.ok,
+      skippedReason: result.skippedReason ?? null,
+      selectedTaskId: result.selectedTaskId ?? null,
+      event: result.auditRecord?.event ?? null,
+    });
+
+    if (index < maxTicks - 1 && intervalMs > 0) {
+      await sleep(intervalMs);
+    }
+  }
+
+  return {
+    schema: DAEMON_WATCH_OUTPUT_SCHEMA,
+    maxTicks,
+    intervalMs,
+    maxDurationMs,
+    elapsedMs: Date.now() - startedAt,
+    tickCount: results.length,
+    dryRun,
+    writeJournal,
+    results,
+  };
+}
+
+function parseCliArgs(argv) {
+  const options = {
+    maxTicks: 2,
+    intervalMs: 1000,
+    maxDurationMs: 600_000,
+    dryRun: false,
+    writeJournal: true,
+    backlogPath: undefined,
+    auditPath: undefined,
+    paused: false,
+  };
+
+  for (let index = 2; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === '--dry-run') {
+      options.dryRun = true;
+      continue;
+    }
+
+    if (arg === '--paused') {
+      options.paused = true;
+      continue;
+    }
+
+    if (arg === '--no-journal') {
+      options.writeJournal = false;
+      continue;
+    }
+
+    if (arg === '--max-ticks') {
+      options.maxTicks = Number.parseInt(argv[index + 1], 10);
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--interval-ms') {
+      options.intervalMs = Number.parseInt(argv[index + 1], 10);
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--max-duration-ms') {
+      options.maxDurationMs = Number.parseInt(argv[index + 1], 10);
+      continue;
+    }
+
+    if (arg === '--backlog') {
+      options.backlogPath = argv[index + 1];
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--audit') {
+      options.auditPath = argv[index + 1];
+      index += 1;
+    }
+  }
+
+  return options;
+}
+
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const cli = parseCliArgs(process.argv);
+  const output = await runWorkGraphDaemonWatch({
+    backlogPath: cli.backlogPath,
+    auditPath: cli.auditPath,
+    maxTicks: cli.maxTicks,
+    intervalMs: cli.intervalMs,
+    maxDurationMs: cli.maxDurationMs,
+    dryRun: cli.dryRun,
+    writeJournal: cli.writeJournal,
+    schedulerPolicy: { paused: cli.paused },
+  });
+
+  console.log(JSON.stringify({
+    schema: output.schema,
+    tickCount: output.tickCount,
+    dryRun: output.dryRun,
+    elapsedMs: output.elapsedMs,
+    results: output.results,
+  }, null, 2));
+}

package/vendor/src/workGraphEngineRoot.mjs

@@ -0,0 +1,136 @@
+import { accessSync, constants } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const DEPRECATED_ENGINE_ROOT =
+  '[work-graph] config.engineRoot устарел — используйте npm install @work-graph/cli или WORKGRAPH_ENGINE_ROOT для разработки WG';
+
+export function defaultEngineRootFromCliModule(cliModuleUrl) {
+  return resolve(dirname(fileURLToPath(cliModuleUrl)), '../../..');
+}
+
+function pathExists(path) {
+  try {
+    accessSync(path, constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function firstExistingPath(candidates) {
+  for (const candidate of candidates) {
+    if (pathExists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+export function isNpmCliPackageRoot(installRoot) {
+  return pathExists(join(installRoot, 'vendor/src/workGraphBacklogUiServer.mjs'));
+}
+
+export function resolveEngineRoot(options = {}) {
+  const { projectRoot, config, cliModuleUrl } = options;
+
+  if (process.env.WORKGRAPH_ENGINE_ROOT) {
+    return resolve(process.env.WORKGRAPH_ENGINE_ROOT);
+  }
+
+  if (config?.engineRoot) {
+    console.warn(DEPRECATED_ENGINE_ROOT);
+    return resolve(config.engineRoot);
+  }
+
+  if (projectRoot) {
+    const fromProject = resolveEngineRootFromNodeModules(projectRoot);
+    if (fromProject) {
+      return fromProject;
+    }
+  }
+
+  if (cliModuleUrl) {
+    const fromCli = defaultEngineRootFromCliModule(cliModuleUrl);
+    if (pathExists(join(fromCli, 'src/workGraphBacklogUiServer.mjs'))) {
+      return fromCli;
+    }
+    const cliPkgRoot = dirname(fileURLToPath(cliModuleUrl));
+    const npmRoot = resolve(cliPkgRoot, '..');
+    if (isNpmCliPackageRoot(npmRoot)) {
+      return npmRoot;
+    }
+  }
+
+  throw new Error(
+    'Не удалось найти Work Graph engine. Выполните: npm install -D @work-graph/cli @work-graph/mcp '
+    + 'или задайте WORKGRAPH_ENGINE_ROOT для разработки WG.',
+  );
+}
+
+export function resolveEngineRootFromNodeModules(projectRoot) {
+  const pkgJsonPath = join(resolve(projectRoot), 'package.json');
+  if (!pathExists(pkgJsonPath)) {
+    return null;
+  }
+  try {
+    const require = createRequire(pkgJsonPath);
+    const cliPkgJson = require.resolve('@work-graph/cli/package.json');
+    return dirname(cliPkgJson);
+  } catch {
+    return null;
+  }
+}
+
+export function resolveBacklogUiServerModule(installRoot) {
+  const root = resolve(installRoot);
+  const hit = firstExistingPath([
+    join(root, 'vendor/src/workGraphBacklogUiServer.mjs'),
+    join(root, 'src/workGraphBacklogUiServer.mjs'),
+  ]);
+  if (!hit) {
+    throw new Error(`workGraphBacklogUiServer.mjs не найден в ${root}`);
+  }
+  return hit;
+}
+
+export function resolveMcpEntryModule(installRoot) {
+  const root = resolve(installRoot);
+  const hit = firstExistingPath([
+    join(root, 'vendor/packages/workgraph-mcp/src/index.mjs'),
+    join(root, 'packages/workgraph-mcp/src/index.mjs'),
+  ]);
+  if (!hit) {
+    throw new Error(`workgraph-mcp entry не найден в ${root}`);
+  }
+  return hit;
+}
+
+export async function importBacklogUiServer(installRoot) {
+  const modulePath = resolveBacklogUiServerModule(installRoot);
+  return import(pathToFileURL(modulePath).href);
+}
+
+export async function importMcpServer(installRoot) {
+  const modulePath = resolveMcpEntryModule(installRoot);
+  return import(pathToFileURL(modulePath).href);
+}
+
+export function buildDoctorReport({ projectRoot, config, engineRoot }) {
+  const root = resolve(projectRoot);
+  const checks = [];
+  const add = (name, ok, detail) => checks.push({ name, ok, detail });
+
+  add('config', Boolean(config), config ? '.work-graph/config.json' : 'нет config — выполните work-graph init');
+  add('intent-index', pathExists(join(root, 'intent/index.bvc')), 'intent/index.bvc');
+  add('engine-root', Boolean(engineRoot), engineRoot ?? 'не резолвится');
+  if (engineRoot) {
+    add('ui-module', pathExists(resolveBacklogUiServerModule(engineRoot)), 'workGraphBacklogUiServer.mjs');
+    add('mcp-module', pathExists(resolveMcpEntryModule(engineRoot)), 'workgraph-mcp entry');
+  }
+  add('npm-cli', Boolean(resolveEngineRootFromNodeModules(root)), '@work-graph/cli в node_modules');
+
+  const ok = checks.every((item) => item.ok);
+  return { ok, schema: 'workgraph.doctor.v1', projectRoot: root, engineRoot, checks };
+}

package/vendor/src/workGraphInstallLayout.mjs

@@ -0,0 +1,65 @@
+import { accessSync, constants } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function pathExists(path) {
+  try {
+    accessSync(path, constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function firstExisting(candidates) {
+  for (const candidate of candidates) {
+    if (pathExists(candidate)) {
+      return candidate;
+    }
+  }
+  return candidates[0];
+}
+
+export function resolveInstallLayout({ moduleUrl, installRootOverride } = {}) {
+  const moduleDir = dirname(fileURLToPath(moduleUrl));
+  let installRoot;
+
+  if (installRootOverride) {
+    installRoot = resolve(installRootOverride);
+  } else if (moduleDir.replace(/\\/gu, '/').includes('/vendor/src')) {
+    installRoot = resolve(moduleDir, '../..');
+  } else {
+    installRoot = resolve(moduleDir, '..');
+  }
+
+  const publicRoot = firstExisting([
+    join(installRoot, 'vendor/public'),
+    join(installRoot, 'public'),
+  ]);
+
+  const designTokensRoot = firstExisting([
+    join(installRoot, 'vendor/packages/design-tokens/generated'),
+    join(installRoot, 'packages/design-tokens/generated'),
+  ]);
+
+  const mermaidPath = firstExisting([
+    join(installRoot, 'node_modules/mermaid/dist/mermaid.min.js'),
+    join(installRoot, '..', 'node_modules/mermaid/dist/mermaid.min.js'),
+    join(installRoot, '..', '..', 'node_modules/mermaid/dist/mermaid.min.js'),
+    join(installRoot, '..', '..', '..', 'node_modules/mermaid/dist/mermaid.min.js'),
+  ]);
+
+  return {
+    installRoot,
+    MERMAID_VENDOR_PATH: mermaidPath,
+    GRAPH_CANVAS_LIT_FLOW_JS_PATH: join(publicRoot, 'graph-canvas-lit-flow.js'),
+    GRAPH_CANVAS_LIT_FLOW_CSS_PATH: join(publicRoot, 'graph-canvas-lit-flow.css'),
+    WORKGRAPH_LOGO_SVG_PATH: join(publicRoot, 'assets/workgraph-logo.svg'),
+    PUBLIC_ROOT: publicRoot,
+    DESIGN_TOKENS_GRIPE_CSS_PATH: join(designTokensRoot, 'gripe-dark-default.css'),
+    DESIGN_TOKENS_WG_CSS_PATH: join(designTokensRoot, 'workgraph-dark.css'),
+    SRC_ROOT: moduleDir.replace(/\\/gu, '/').includes('/vendor/src')
+      ? join(installRoot, 'vendor/src')
+      : moduleDir,
+  };
+}