@work-graph/cli 0.2.0

package/vendor/src/workGraphBoundedTargetFileRead.mjs

@@ -0,0 +1,178 @@
+import { posix, resolve } from 'node:path';
+
+export const BOUNDED_TARGET_FILE_READ_SCHEMA = 'workgraph.bounded-target-file-read.v1';
+
+export const DEFAULT_MAX_BYTES_PER_FILE = 32_768;
+export const DEFAULT_MAX_TOTAL_BYTES = 131_072;
+
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+export function normalizeBoundedTargetPath(rawPath, repoRoot = '') {
+  const normalized = String(rawPath ?? '').trim().replace(/\\/gu, '/');
+  if (normalized === '') {
+    return { ok: false, error: 'empty path' };
+  }
+
+  if (normalized.startsWith('/') || /^[a-zA-Z]:/u.test(normalized)) {
+    return { ok: false, error: 'absolute paths are not allowed' };
+  }
+
+  if (normalized.split('/').includes('..')) {
+    return { ok: false, error: 'path traversal is not allowed' };
+  }
+
+  const cleaned = posix.normalize(normalized).replace(/^\.\//u, '');
+  if (cleaned === '..' || cleaned.startsWith('../')) {
+    return { ok: false, error: 'path traversal is not allowed' };
+  }
+
+  if (repoRoot) {
+    const absolute = resolve(repoRoot, cleaned);
+    const root = resolve(repoRoot);
+    if (!absolute.startsWith(root)) {
+      return { ok: false, error: 'path escapes repo root' };
+    }
+  }
+
+  return { ok: true, path: cleaned };
+}
+
+export function isPathAllowedForTargetFiles(path, targetFiles) {
+  const allowed = new Set(
+    (targetFiles ?? []).map((entry) => normalizeBoundedTargetPath(entry).path).filter(Boolean),
+  );
+  const normalized = normalizeBoundedTargetPath(path);
+  return normalized.ok && allowed.has(normalized.path);
+}
+
+export async function readBoundedTargetFile(path, options = {}) {
+  const targetFiles = options.targetFiles ?? [];
+  const repoRoot = options.repoRoot ?? options.cwd ?? process.cwd();
+  const maxBytes = options.maxBytesPerFile ?? DEFAULT_MAX_BYTES_PER_FILE;
+  const readFileImpl = options.readFile ?? (async (filePath) => {
+    const { readFile } = await import('node:fs/promises');
+    return readFile(filePath, 'utf8');
+  });
+
+  if (!isPathAllowedForTargetFiles(path, targetFiles)) {
+    return {
+      path: String(path),
+      ok: false,
+      error: 'path is not in task targetFiles allowlist',
+      content: '',
+      truncated: false,
+      byteLength: 0,
+    };
+  }
+
+  const normalized = normalizeBoundedTargetPath(path, repoRoot);
+  if (!normalized.ok) {
+    return {
+      path: String(path),
+      ok: false,
+      error: normalized.error,
+      content: '',
+      truncated: false,
+      byteLength: 0,
+    };
+  }
+
+  const absolutePath = resolve(repoRoot, normalized.path);
+
+  try {
+    const content = await readFileImpl(absolutePath);
+    const text = String(content);
+    const byteLength = Buffer.byteLength(text, 'utf8');
+    const truncated = byteLength > maxBytes;
+    const slice = truncated ? Buffer.from(text, 'utf8').subarray(0, maxBytes).toString('utf8') : text;
+
+    return {
+      path: normalized.path,
+      ok: true,
+      error: '',
+      content: slice,
+      truncated,
+      byteLength,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      path: normalized.path,
+      ok: false,
+      error: message,
+      content: '',
+      truncated: false,
+      byteLength: 0,
+    };
+  }
+}
+
+export async function readBoundedTargetFiles(input, options = {}) {
+  const targetFiles = [...(options.targetFiles ?? input?.targetFiles ?? [])]
+    .map(String)
+    .filter(Boolean)
+    .sort(compareText);
+
+  const maxBytesPerFile = options.maxBytesPerFile ?? DEFAULT_MAX_BYTES_PER_FILE;
+  const maxTotalBytes = options.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES;
+  const repoRoot = options.repoRoot ?? options.cwd ?? process.cwd();
+
+  const files = [];
+  let totalBytes = 0;
+
+  for (const path of targetFiles) {
+    if (totalBytes >= maxTotalBytes) {
+      files.push({
+        path,
+        ok: false,
+        error: 'total byte budget exceeded',
+        content: '',
+        truncated: false,
+        byteLength: 0,
+      });
+      continue;
+    }
+
+    const remaining = maxTotalBytes - totalBytes;
+    const entry = await readBoundedTargetFile(path, {
+      targetFiles,
+      repoRoot,
+      maxBytesPerFile: Math.min(maxBytesPerFile, remaining),
+      readFile: options.readFile,
+    });
+
+    files.push(entry);
+    if (entry.ok) {
+      totalBytes += Buffer.byteLength(entry.content, 'utf8');
+    }
+  }
+
+  return {
+    schema: BOUNDED_TARGET_FILE_READ_SCHEMA,
+    taskId: input?.task?.id ?? '',
+    allowedPaths: targetFiles,
+    files,
+    summary: {
+      requested: targetFiles.length,
+      readOk: files.filter((entry) => entry.ok).length,
+      failed: files.filter((entry) => !entry.ok).length,
+      truncated: files.filter((entry) => entry.truncated).length,
+      totalBytes,
+    },
+  };
+}
+
+export function formatBoundedTargetFilesForPrompt(readResult) {
+  if (!readResult?.files?.length) {
+    return 'No target file contents available.';
+  }
+
+  return readResult.files.map((entry) => {
+    if (!entry.ok) {
+      return `# ${entry.path}\n(error: ${entry.error})`;
+    }
+
+    const suffix = entry.truncated ? '\n...(truncated)' : '';
+    return `# ${entry.path}\n${entry.content}${suffix}`;
+  }).join('\n\n');
+}

package/vendor/src/workGraphCycleSlice.mjs

@@ -0,0 +1,184 @@
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+export const CYCLE_SLICE_SCHEMA = 'workgraph.cycle.slice.v1';
+export const PHASE_EPIC_PATTERN = /^phase-\d+/u;
+export const DONE_STATUSES = new Set(['done', 'verified']);
+export const OPERATIONAL_STATUSES = new Set(['ready', 'claimed', 'doing', 'in_progress', 'verify', 'blocked']);
+export const DEFAULT_DONE_ARCHIVE_CAP = 12;
+
+export function sortDoneArchiveItems(items) {
+  return [...items].sort((left, right) => compareText(right.id, left.id));
+}
+
+export function selectDoneArchiveItems(items, cap = DEFAULT_DONE_ARCHIVE_CAP) {
+  return sortDoneArchiveItems(items.filter((item) => DONE_STATUSES.has(item.status))).slice(0, cap);
+}
+
+export function deriveWorkCycle(item, itemById) {
+  if (!item || typeof item !== 'object') {
+    throw new TypeError('item must be an object');
+  }
+
+  const explicitCycle = String(item.labels?.['work.cycle'] ?? item.cycle ?? '').trim();
+  if (explicitCycle !== '') {
+    return explicitCycle;
+  }
+
+  if (PHASE_EPIC_PATTERN.test(item.id)) {
+    return item.id;
+  }
+
+  const visited = new Set();
+  const queue = [...(item.dependsOn ?? [])];
+
+  while (queue.length > 0) {
+    const dependencyId = queue.shift();
+    if (visited.has(dependencyId)) {
+      continue;
+    }
+    visited.add(dependencyId);
+
+    if (PHASE_EPIC_PATTERN.test(dependencyId)) {
+      return dependencyId;
+    }
+
+    const dependency = itemById.get(dependencyId);
+    if (dependency?.labels?.['work.cycle']) {
+      return String(dependency.labels['work.cycle']).trim();
+    }
+
+    for (const nextId of dependency?.dependsOn ?? []) {
+      if (!visited.has(nextId)) {
+        queue.push(nextId);
+      }
+    }
+  }
+
+  return 'uncategorized';
+}
+
+export function resolveCurrentCycle(items, itemById) {
+  const activeItems = items.filter((item) => OPERATIONAL_STATUSES.has(item.status) && item.status !== 'backlog');
+  const cycles = activeItems.map((item) => deriveWorkCycle(item, itemById));
+
+  const phaseCycles = cycles.filter((cycle) => PHASE_EPIC_PATTERN.test(cycle));
+  if (phaseCycles.length > 0) {
+    return [...phaseCycles].sort((left, right) => comparePhaseEpic(right, left))[0];
+  }
+
+  const readyItem = items.find((item) => item.status === 'ready');
+  if (readyItem) {
+    return deriveWorkCycle(readyItem, itemById);
+  }
+
+  return cycles[0] ?? 'uncategorized';
+}
+
+export function buildCycleSliceProjection(items, options = {}) {
+  const stableItems = [...items].sort((left, right) => compareText(left.id, right.id));
+  const itemById = new Map(stableItems.map((item) => [item.id, item]));
+  const doneArchiveCap = options.doneArchiveCap ?? DEFAULT_DONE_ARCHIVE_CAP;
+
+  const cyclesMap = new Map();
+  for (const item of stableItems) {
+    const cycleId = deriveWorkCycle(item, itemById);
+    const bucket = cyclesMap.get(cycleId) ?? {
+      id: cycleId,
+      label: formatCycleLabel(cycleId),
+      total: 0,
+      done: 0,
+      active: 0,
+      backlog: 0,
+    };
+
+    bucket.total += 1;
+    if (DONE_STATUSES.has(item.status)) {
+      bucket.done += 1;
+    } else if (item.status === 'backlog') {
+      bucket.backlog += 1;
+    } else {
+      bucket.active += 1;
+    }
+
+    cyclesMap.set(cycleId, bucket);
+  }
+
+  const currentCycle = options.currentCycle ?? resolveCurrentCycle(stableItems, itemById);
+
+  return {
+    schema: CYCLE_SLICE_SCHEMA,
+    currentCycle,
+    doneArchiveCap,
+    operationalStatuses: [...OPERATIONAL_STATUSES],
+    derivedByWorkId: Object.fromEntries(
+      stableItems.map((item) => [item.id, deriveWorkCycle(item, itemById)]),
+    ),
+    cycles: [...cyclesMap.values()].sort((left, right) => compareText(left.id, right.id)),
+  };
+}
+
+export function filterItemsByCycleSlice(items, options = {}) {
+  const stableItems = [...items].sort((left, right) => compareText(left.id, right.id));
+  const itemById = new Map(stableItems.map((item) => [item.id, item]));
+  const cycleId = options.cycleId ?? 'current';
+  const resolvedCycle = cycleId === 'current'
+    ? resolveCurrentCycle(stableItems, itemById)
+    : cycleId;
+  const includeAllCycles = resolvedCycle === 'all';
+  const operationalOnly = options.operationalOnly !== false;
+  const doneArchiveCap = options.doneArchiveCap ?? DEFAULT_DONE_ARCHIVE_CAP;
+
+  const cycleMatched = includeAllCycles
+    ? stableItems
+    : stableItems.filter((item) => deriveWorkCycle(item, itemById) === resolvedCycle);
+
+  if (!operationalOnly) {
+    return cycleMatched;
+  }
+
+  const operational = cycleMatched.filter((item) => OPERATIONAL_STATUSES.has(item.status));
+  const doneArchive = selectDoneArchiveItems(cycleMatched, doneArchiveCap);
+
+  return [...operational, ...doneArchive];
+}
+
+export function partitionBoardItems(items, options = {}) {
+  const filtered = filterItemsByCycleSlice(items, options);
+  const operational = filtered.filter((item) => OPERATIONAL_STATUSES.has(item.status));
+  const doneArchive = selectDoneArchiveItems(filtered, options.doneArchiveCap ?? DEFAULT_DONE_ARCHIVE_CAP);
+  const hiddenDoneCount = Math.max(0, countDoneInCycle(items, options) - doneArchive.length);
+
+  return {
+    operational,
+    doneArchive,
+    hiddenDoneCount,
+    totalVisible: filtered.length,
+  };
+}
+
+function countDoneInCycle(items, options) {
+  const itemById = new Map(items.map((item) => [item.id, item]));
+  const cycleId = options.cycleId ?? 'current';
+  const resolvedCycle = cycleId === 'current'
+    ? resolveCurrentCycle(items, itemById)
+    : cycleId;
+
+  if (resolvedCycle === 'all') {
+    return items.filter((item) => DONE_STATUSES.has(item.status)).length;
+  }
+
+  return items.filter((item) => DONE_STATUSES.has(item.status) && deriveWorkCycle(item, itemById) === resolvedCycle).length;
+}
+
+function formatCycleLabel(cycleId) {
+  if (cycleId === 'uncategorized') {
+    return 'Без цикла';
+  }
+  return cycleId.replace(/^phase-/u, 'Фаза ').replace(/-/gu, ' · ');
+}
+
+function comparePhaseEpic(left, right) {
+  const leftNum = Number.parseInt(String(left).match(/^phase-(\d+)/u)?.[1] ?? '0', 10);
+  const rightNum = Number.parseInt(String(right).match(/^phase-(\d+)/u)?.[1] ?? '0', 10);
+  return leftNum - rightNum;
+}

package/vendor/src/workGraphDaemonTick.mjs

@@ -0,0 +1,307 @@
+import { appendFile, readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import {
+  appendWorkerRunJournal,
+  runAgentWorkerLiveLoop,
+} from './agentWorkerLiveLoop.mjs';
+import { readWorkItemsFromRepo } from './intentTreeWorkItems.mjs';
+import { buildRecoverySuggestionFromWorkerOutput } from './workGraphRecoveryPolicy.mjs';
+
+export const DAEMON_TICK_PHASES = ['observe', 'schedule', 'run', 'recovery', 'audit', 'stop'];
+
+const TICK_OUTPUT_SCHEMA = 'workgraph.daemon.tick.output.v1';
+export const DAEMON_AUDIT_TAIL_SCHEMA = 'workgraph.daemon-audit.tail.v1';
+const DEFAULT_AUDIT_PATH = 'work/daemon-audit.jsonl';
+const DEFAULT_WORKER_RUNS_PATH = 'work/worker-runs.jsonl';
+const DEFAULT_AUDIT_TAIL_LIMIT = 24;
+const MAX_AUDIT_TAIL_LIMIT = 200;
+
+export function buildDaemonTickAuditRecord(tickMeta) {
+  return {
+    tickId: tickMeta.tickId,
+    event: tickMeta.event,
+    taskId: tickMeta.taskId ?? '',
+    workerStatus: tickMeta.workerStatus ?? '',
+    recoveryClass: tickMeta.recoveryClass ?? '',
+    summary: tickMeta.summary ?? '',
+    recordedAt: tickMeta.recordedAt ?? new Date().toISOString(),
+  };
+}
+
+export async function runWorkGraphDaemonTick(items, options = {}) {
+  const tickId = options.tickId ?? `tick-${Date.now()}`;
+  const phases = [];
+  const schedulerPolicy = {
+    paused: false,
+    dryRun: false,
+    ...(options.schedulerPolicy ?? {}),
+  };
+
+  phases.push({ phase: 'observe', detail: 'read snapshot', itemCount: items.length });
+
+  if (schedulerPolicy.paused) {
+    phases.push({ phase: 'schedule', detail: 'scheduler paused', skipped: true });
+    phases.push({ phase: 'stop', detail: 'tick skipped' });
+    return buildTickOutput({
+      ok: true,
+      tickId,
+      phases,
+      skippedReason: 'scheduler_paused',
+      auditRecord: buildDaemonTickAuditRecord({
+        tickId,
+        event: 'tick_skipped',
+        summary: 'scheduler paused',
+        recordedAt: options.recordedAt,
+      }),
+    });
+  }
+
+  const loopOptions = {
+    taskId: options.taskId,
+    runId: options.runId ?? `daemon-${tickId}`,
+    workerInput: options.workerInput,
+    runWorker: options.runWorker,
+    provider: options.provider,
+    providerOptions: options.providerOptions,
+    selectionOptions: options.selectionOptions,
+    enableFallback: options.enableFallback,
+    maxFallbackAttempts: options.maxFallbackAttempts,
+    recordedAt: options.recordedAt,
+  };
+
+  if (schedulerPolicy.dryRun) {
+    const pool = cloneItems(items);
+    const selected = options.taskId
+      ? pool.find((item) => item.id === options.taskId)
+      : pool.find((item) => item.status === 'ready');
+
+    phases.push({
+      phase: 'schedule',
+      detail: selected ? `dry-run selected ${selected.id}` : 'no task selected',
+      taskId: selected?.id,
+    });
+    phases.push({ phase: 'stop', detail: 'dry-run complete' });
+
+    return buildTickOutput({
+      ok: true,
+      tickId,
+      phases,
+      selectedTaskId: selected?.id ?? null,
+      skippedReason: selected ? 'dry_run' : 'no_claimable_task',
+      auditRecord: buildDaemonTickAuditRecord({
+        tickId,
+        event: 'tick_skipped',
+        taskId: selected?.id,
+        summary: selected ? 'dry-run schedule only' : 'no claimable task',
+        recordedAt: options.recordedAt,
+      }),
+      recoverySuggestion: buildRecoverySuggestionFromWorkerOutput(null, {
+        noClaimableTask: !selected,
+      }),
+    });
+  }
+
+  phases.push({ phase: 'schedule', detail: 'delegate to live-loop claimNext policy' });
+
+  const loopResult = await runAgentWorkerLiveLoop(items, loopOptions);
+
+  phases.push({
+    phase: 'run',
+    detail: 'live-loop worker run',
+    taskId: loopResult.taskId,
+    workerStatus: loopResult.workerOutput?.status,
+    ok: loopResult.ok,
+  });
+
+  const recoverySuggestion = buildRecoverySuggestionFromWorkerOutput(loopResult.workerOutput ?? null, {
+    noClaimableTask: loopResult.error === 'no_claimable_task',
+    retryCount: options.retryCount,
+    maxRetries: options.maxRetries,
+    taskStatus: loopResult.finalItems?.find((item) => item.id === loopResult.taskId)?.status,
+  });
+
+  phases.push({
+    phase: 'recovery',
+    detail: recoverySuggestion.preset,
+    action: recoverySuggestion.action,
+  });
+
+  const auditRecord = buildDaemonTickAuditRecord({
+    tickId,
+    event: loopResult.ok ? 'worker_run_finished' : 'tick_failed',
+    taskId: loopResult.taskId,
+    workerStatus: loopResult.workerOutput?.status,
+    recoveryClass: recoverySuggestion.failureClass,
+    summary: loopResult.workerOutput?.patchSummary?.summary || loopResult.error || recoverySuggestion.reason,
+    recordedAt: options.recordedAt,
+  });
+
+  phases.push({ phase: 'audit', detail: 'build audit record', event: auditRecord.event });
+  phases.push({ phase: 'stop', detail: 'tick complete', taskId: loopResult.taskId });
+
+  return buildTickOutput({
+    ok: loopResult.ok,
+    tickId,
+    phases,
+    selectedTaskId: loopResult.taskId ?? null,
+    error: loopResult.error,
+    workerOutput: loopResult.workerOutput,
+    workerRunSummary: loopResult.workerRunSummary,
+    auditRecord,
+    recoverySuggestion,
+    finalItems: loopResult.finalItems,
+  });
+}
+
+export async function runWorkGraphDaemonTickFromBacklogFile(options = {}) {
+  const items = await readWorkItemsFromRepo(options);
+  return runWorkGraphDaemonTick(items, options);
+}
+
+export async function appendDaemonAuditJournal(entry, options = {}) {
+  const journalPath = resolve(options.cwd ?? process.cwd(), options.auditPath ?? DEFAULT_AUDIT_PATH);
+  await appendFile(journalPath, `${JSON.stringify(entry)}\n`, 'utf8');
+  return journalPath;
+}
+
+export async function readDaemonAuditJournal(options = {}) {
+  const journalPath = resolve(options.cwd ?? process.cwd(), options.auditPath ?? DEFAULT_AUDIT_PATH);
+
+  try {
+    const text = await readFile(journalPath, 'utf8');
+    return text
+      .split(/\r?\n/u)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  } catch (error) {
+    if (error && typeof error === 'object' && error.code === 'ENOENT') {
+      return [];
+    }
+
+    throw error;
+  }
+}
+
+export async function readDaemonAuditTailResponse(options = {}) {
+  const limitRaw = options.limit;
+  const limit = Number.isInteger(limitRaw) && limitRaw > 0
+    ? Math.min(limitRaw, MAX_AUDIT_TAIL_LIMIT)
+    : DEFAULT_AUDIT_TAIL_LIMIT;
+  const auditPath = options.auditPath ?? DEFAULT_AUDIT_PATH;
+  const entries = await readDaemonAuditJournal({ ...options, auditPath });
+
+  return {
+    schema: DAEMON_AUDIT_TAIL_SCHEMA,
+    journalPath: auditPath,
+    limit,
+    totalCount: entries.length,
+    truncated: entries.length > limit,
+    entries: entries.slice(-limit).reverse(),
+  };
+}
+
+function buildTickOutput(fields) {
+  return {
+    schema: TICK_OUTPUT_SCHEMA,
+    ...fields,
+  };
+}
+
+function cloneItems(items) {
+  return items.map((item) => ({
+    ...item,
+    dependsOn: [...item.dependsOn],
+    evidence: [...item.evidence],
+    checks: [...item.checks],
+    labels: { ...item.labels },
+  }));
+}
+
+function parseCliArgs(argv) {
+  const args = argv.slice(2);
+  const options = {
+    once: false,
+    dryRun: false,
+    paused: false,
+    writeJournal: true,
+    taskId: undefined,
+    backlogPath: undefined,
+    auditPath: DEFAULT_AUDIT_PATH,
+    workerRunsPath: DEFAULT_WORKER_RUNS_PATH,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--once') {
+      options.once = true;
+      continue;
+    }
+
+    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 === '--backlog') {
+      options.backlogPath = args[index + 1];
+      index += 1;
+      continue;
+    }
+
+    if (!arg.startsWith('--') && options.taskId === undefined) {
+      options.taskId = arg;
+    }
+  }
+
+  return options;
+}
+
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const cli = parseCliArgs(process.argv);
+
+  if (!cli.once) {
+    console.error('Usage: node src/workGraphDaemonTick.mjs --once [--dry-run] [--paused] [--backlog path/to/backlog.bvc] [taskId]');
+    process.exitCode = 1;
+  } else {
+    const result = await runWorkGraphDaemonTickFromBacklogFile({
+      taskId: cli.taskId,
+      backlogPath: cli.backlogPath,
+      schedulerPolicy: { paused: cli.paused, dryRun: cli.dryRun },
+    });
+
+    if (cli.writeJournal && result.auditRecord) {
+      await appendDaemonAuditJournal(result.auditRecord, { auditPath: cli.auditPath });
+    }
+
+    if (cli.writeJournal && result.workerRunSummary && !cli.dryRun && !cli.paused) {
+      await appendWorkerRunJournal(result.workerRunSummary, { journalPath: cli.workerRunsPath });
+    }
+
+    console.log(JSON.stringify({
+      ok: result.ok,
+      tickId: result.tickId,
+      selectedTaskId: result.selectedTaskId,
+      skippedReason: result.skippedReason,
+      recoverySuggestion: result.recoverySuggestion,
+      phases: result.phases?.map((step) => step.phase),
+    }, null, 2));
+
+    if (!result.ok && result.skippedReason !== 'dry_run' && result.skippedReason !== 'scheduler_paused') {
+      process.exitCode = 1;
+    }
+  }
+}