sdd-agent-platform 0.4.0 → 0.4.2

package/node_modules/@sdd-agent-platform/core/src/workflow-state/resolve-task-run.ts

@@ -0,0 +1,114 @@
+import type { RunState } from '../run-state/model.js';
+import { readAllRunStates, readRunState } from '../run-state/run-state.js';
+import type { ContextResolverContract } from '../sdd-docs/context.js';
+import { resolveRunStateContext, resolveSddContext } from '../sdd-docs/context.js';
+import { documentHashMatches } from '../sdd-docs/document-hashes.js';
+import { inspectSddTask } from '../sdd-docs/task-inspection.js';
+import { parseSddBranch, type SddTask, type SddTaskModel } from '../sdd-docs/task-parser.js';
+import { affectedFileConflictsForSelectedRun, type WorkflowAffectedFileConflict } from './affected-file-conflicts.js';
+import { resolveWorkflowState } from './resolve.js';
+
+export interface ResolvedTaskRun {
+  runId: string;
+  state: RunState;
+  context: ContextResolverContract;
+  model: SddTaskModel;
+  task: SddTask | null;
+  explicitRunId: boolean;
+  staleReasons: string[];
+  affectedFileConflicts: WorkflowAffectedFileConflict[];
+  selectorRejectionReasons: string[];
+}
+
+export async function resolveTaskRun(projectRoot: string, options: { runId?: string; branch?: string; taskId: string }): Promise<ResolvedTaskRun> {
+  if (options.runId) {
+    const state = await readRunState(projectRoot, options.runId);
+    const context = options.branch
+      ? await resolveSddContext(projectRoot, { branch: options.branch, branchSource: 'cli_option' })
+      : await resolveRunStateContext(projectRoot, state);
+    const model = await parseSddBranch(projectRoot, context.partition);
+    const inspected = inspectSddTask(model, options.taskId);
+    if (state.partition && state.partition !== context.partition) {
+      throw new Error(`Run ${state.runId} belongs to partition ${state.partition}, not ${context.partition}.`);
+    }
+    if (state.taskId && state.taskId !== options.taskId) {
+      throw new Error(`Run ${state.runId} belongs to task ${state.taskId}, not ${options.taskId}.`);
+    }
+    return {
+      runId: state.runId,
+      state,
+      context,
+      model,
+      task: inspected.task,
+      explicitRunId: true,
+      staleReasons: runDocumentStaleReasons(state, model),
+      affectedFileConflicts: await affectedFileConflictsForRun(projectRoot, state),
+      selectorRejectionReasons: []
+    };
+  }
+
+  const workflow = await resolveWorkflowState(projectRoot, {
+    branch: options.branch,
+    branchSource: options.branch ? 'cli_option' : undefined,
+    taskId: options.taskId
+  });
+  const inspected = inspectSddTask(workflow.model, options.taskId);
+  const selection = workflow.latestEligibleRunsByTask.find((entry) => entry.taskId === options.taskId);
+  const candidate = selection?.selected ?? selection?.rejected[0] ?? null;
+  if (!candidate) {
+    throw new Error(`No eligible run found for ${workflow.context.partition}/${options.taskId}. Run sdd do task ${options.taskId} first, or pass --run <run_id>.`);
+  }
+  const state = selection?.selected && workflow.latestRunState && selection.selected.runId === workflow.latestRunState.runId
+    ? workflow.latestRunState
+    : await readRunState(projectRoot, candidate.runId);
+  if (!state) {
+    throw new Error(`Run state ${candidate.runId} is unavailable for ${workflow.context.partition}/${options.taskId}. Pass --run <run_id> or rerun the task.`);
+  }
+  return {
+    runId: state.runId,
+    state,
+    context: workflow.context,
+    model: workflow.model,
+    task: inspected.task,
+    explicitRunId: false,
+    staleReasons: runDocumentStaleReasons(state, workflow.model),
+    affectedFileConflicts: workflow.affectedFileConflicts,
+    selectorRejectionReasons: selection?.selected ? [] : candidate.reasons
+  };
+}
+
+export function runDocumentStaleReasons(state: RunState, model: SddTaskModel): string[] {
+  const reasons: string[] = [];
+  const snapshot = state.documentSnapshot;
+  if (!snapshot.specHash && !snapshot.planHash && !snapshot.tasksHash) {
+    reasons.push('Run has no document snapshot hashes; rerun do task before test or goal-verify.');
+  }
+  appendDocumentHashMismatch(reasons, 'spec.md', snapshot.specHash, model.documents.specHash ?? null);
+  appendDocumentHashMismatch(reasons, 'plan.md', snapshot.planHash, model.documents.planHash ?? null);
+  appendDocumentHashMismatch(reasons, 'tasks.md', snapshot.tasksHash, model.documents.tasksHash ?? null);
+  if (model.documents.planStale) {
+    reasons.push('Current plan.md is stale against spec.md.');
+  }
+  if (model.documents.tasksStale) {
+    reasons.push('Current tasks.md is stale against plan.md or spec.md.');
+  }
+  return reasons;
+}
+
+async function affectedFileConflictsForRun(projectRoot: string, state: RunState): Promise<WorkflowAffectedFileConflict[]> {
+  const states = await readAllRunStates(projectRoot);
+  return affectedFileConflictsForSelectedRun(states, state);
+}
+
+function appendDocumentHashMismatch(reasons: string[], documentName: string, expected: string | null, actual: string | null): void {
+  if (shouldReportDocumentHashMismatch(expected, actual)) {
+    reasons.push(`Run snapshot for ${documentName} is ${expected ?? 'missing'}, current hash is ${actual ?? 'missing'}.`);
+  }
+}
+
+function shouldReportDocumentHashMismatch(expected: string | null, actual: string | null): boolean {
+  if (!expected && !actual) {
+    return false;
+  }
+  return !expected || !actual || !documentHashMatches(expected, actual);
+}