@leonarto/spec-embryo 0.1.0

package/src/domain.ts

@@ -0,0 +1,357 @@
+export const SPEC_STATUSES = ["proposed", "active", "paused", "done", "archived"] as const;
+export const TASK_STATUSES = ["todo", "in_progress", "blocked", "review", "done", "cancelled"] as const;
+export const HANDOFF_KINDS = ["checkpoint", "resume", "decision", "release"] as const;
+export const BACKEND_NAMES = ["deterministic", "prompt", "codex", "claude"] as const;
+
+export type SpecStatus = (typeof SPEC_STATUSES)[number];
+export type TaskStatus = (typeof TASK_STATUSES)[number];
+export type HandoffKind = (typeof HANDOFF_KINDS)[number];
+export type BackendName = (typeof BACKEND_NAMES)[number];
+
+export function isSpecStatus(value: string): value is SpecStatus {
+  return SPEC_STATUSES.includes(value as SpecStatus);
+}
+
+export function isTaskStatus(value: string): value is TaskStatus {
+  return TASK_STATUSES.includes(value as TaskStatus);
+}
+
+export interface BaseDocument {
+  docKind: string;
+  id: string;
+  title: string;
+  summary: string;
+  tags: string[];
+  body: string;
+  filePath: string;
+  updatedAt?: string;
+}
+
+export interface SpecDocument extends BaseDocument {
+  docKind: "spec";
+  status: SpecStatus;
+  taskIds: string[];
+  owner?: string;
+}
+
+export interface TaskDocument extends BaseDocument {
+  docKind: "task";
+  status: TaskStatus;
+  specIds: string[];
+  dependsOn: string[];
+  blockedBy: string[];
+  priority: number;
+  ownerRole?: string;
+  createdAt?: string;
+  completedAt?: string;
+  cancelledAt?: string;
+  archivedAt?: string;
+  archiveReason?: string;
+}
+
+export interface HandoffDocument extends BaseDocument {
+  docKind: "handoff";
+  handoffKind: HandoffKind;
+  createdAt: string;
+  activeTaskIds: string[];
+  relatedSpecIds: string[];
+  author: string;
+}
+
+export interface CurrentStateDocument extends BaseDocument {
+  docKind: "current-state";
+  focus: string;
+  activeSpecIds: string[];
+  activeTaskIds: string[];
+  blockedTaskIds: string[];
+  nextActionHints: string[];
+  lastHandoffId?: string;
+}
+
+export interface ExecutionBackendConfig {
+  enabled: boolean;
+  command?: string;
+  args?: string[];
+}
+
+export interface ProjectConfig {
+  toolVersion: string;
+  projectName: string;
+  memoryDir: string;
+  stateFile: string;
+  handoffsDir: string;
+  specsDir: string;
+  tasksDir: string;
+  skillsDir: string;
+  defaults: {
+    resumeBackend: BackendName;
+  };
+  backends: {
+    deterministic: { enabled: boolean };
+    prompt: { enabled: boolean };
+    codex: ExecutionBackendConfig;
+    claude: ExecutionBackendConfig;
+  };
+}
+
+export interface GitSnapshot {
+  available: boolean;
+  branch?: string;
+  shortStatus: string[];
+  lastCommit?: string;
+  dirty: boolean;
+}
+
+export interface ChangedItemSummary {
+  kind: "spec" | "task" | "current-state" | "handoff" | "other";
+  path: string;
+  id?: string;
+  title?: string;
+}
+
+export interface TaskNodeSummary {
+  task: TaskDocument;
+  unmetDependencies: string[];
+  downstreamCount: number;
+}
+
+export interface ProjectContext {
+  rootDir: string;
+  config: ProjectConfig;
+  currentState: CurrentStateDocument;
+  specs: SpecDocument[];
+  tasks: TaskDocument[];
+  handoffs: HandoffDocument[];
+  git: GitSnapshot;
+}
+
+export interface StatusSnapshot {
+  specCount: number;
+  taskCount: number;
+  activeSpecIds: string[];
+  activeTaskIds: string[];
+  blockedTasks: TaskNodeSummary[];
+  reviewTasks: TaskNodeSummary[];
+  readyTasks: TaskNodeSummary[];
+  inProgressTasks: TaskDocument[];
+  recentHandoff?: HandoffDocument;
+  criticalPath: TaskDocument[];
+  missingDependencies: Array<{ taskId: string; missingTaskId: string }>;
+  changedItems: ChangedItemSummary[];
+}
+
+export interface ResumeContext {
+  projectName: string;
+  focus: string;
+  summary: string;
+  activeSpecs: SpecDocument[];
+  activeTasks: TaskNodeSummary[];
+  blockedTasks: TaskNodeSummary[];
+  reviewTasks: TaskNodeSummary[];
+  readyTasks: TaskNodeSummary[];
+  criticalPath: TaskDocument[];
+  recentHandoff?: HandoffDocument;
+  nextActions: string[];
+  git: GitSnapshot;
+  changedItems: ChangedItemSummary[];
+}
+
+function fail(message: string): never {
+  throw new Error(message);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function asString(value: unknown, field: string, filePath: string, fallback?: string): string {
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value.trim();
+  }
+
+  if (fallback !== undefined) {
+    return fallback;
+  }
+
+  fail(`Expected "${field}" to be a non-empty string in ${filePath}`);
+}
+
+function asOptionalString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+
+function asStringArray(value: unknown, field: string, filePath: string): string[] {
+  if (value === undefined) {
+    return [];
+  }
+
+  if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+    return value.map((item) => item.trim()).filter(Boolean);
+  }
+
+  fail(`Expected "${field}" to be an array of strings in ${filePath}`);
+}
+
+function asNumber(value: unknown, field: string, filePath: string, fallback: number): number {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+
+  return fallback;
+}
+
+function asEnum<T extends readonly string[]>(
+  value: unknown,
+  allowed: T,
+  field: string,
+  filePath: string,
+  fallback?: T[number],
+): T[number] {
+  if (typeof value === "string" && allowed.includes(value as T[number])) {
+    return value as T[number];
+  }
+
+  if (fallback !== undefined) {
+    return fallback;
+  }
+
+  fail(`Expected "${field}" in ${filePath} to be one of: ${allowed.join(", ")}`);
+}
+
+export function parseProjectConfig(data: unknown): ProjectConfig {
+  if (!isRecord(data)) {
+    fail("Project config must be a TOML object.");
+  }
+
+  const defaults = isRecord(data.defaults) ? data.defaults : {};
+  const backends = isRecord(data.backends) ? data.backends : {};
+  const deterministicBackend = isRecord(backends.deterministic) ? backends.deterministic : {};
+  const promptBackend = isRecord(backends.prompt) ? backends.prompt : {};
+  const codexBackend = isRecord(backends.codex) ? backends.codex : {};
+  const claudeBackend = isRecord(backends.claude) ? backends.claude : {};
+
+  return {
+    toolVersion: asString(data.tool_version, "tool_version", ".specpm/config.toml"),
+    projectName: asString(data.project_name, "project_name", ".specpm/config.toml"),
+    memoryDir: asString(data.memory_dir, "memory_dir", ".specpm/config.toml", "docs/spm"),
+    stateFile: asString(data.state_file, "state_file", ".specpm/config.toml", "docs/spm/current.md"),
+    handoffsDir: asString(data.handoffs_dir, "handoffs_dir", ".specpm/config.toml", "docs/spm/handoffs"),
+    specsDir: asString(data.specs_dir, "specs_dir", ".specpm/config.toml", "docs/spm/specs"),
+    tasksDir: asString(data.tasks_dir, "tasks_dir", ".specpm/config.toml", "docs/spm/tasks"),
+    skillsDir: asString(data.skills_dir, "skills_dir", ".specpm/config.toml", "docs/spm/skills"),
+    defaults: {
+      resumeBackend: asEnum(defaults.resume_backend, BACKEND_NAMES, "defaults.resume_backend", ".specpm/config.toml", "deterministic"),
+    },
+    backends: {
+      deterministic: {
+        enabled: deterministicBackend.enabled !== false,
+      },
+      prompt: {
+        enabled: promptBackend.enabled !== false,
+      },
+      codex: {
+        enabled: codexBackend.enabled === true,
+        command: asOptionalString(codexBackend.command),
+        args: asStringArray(codexBackend.args, "backends.codex.args", ".specpm/config.toml"),
+      },
+      claude: {
+        enabled: claudeBackend.enabled === true,
+        command: asOptionalString(claudeBackend.command),
+        args: asStringArray(claudeBackend.args, "backends.claude.args", ".specpm/config.toml"),
+      },
+    },
+  };
+}
+
+export function parseSpecDocument(filePath: string, attributes: unknown, body: string): SpecDocument {
+  if (!isRecord(attributes)) {
+    fail(`Invalid frontmatter in ${filePath}`);
+  }
+
+  return {
+    docKind: asEnum(attributes.doc_kind, ["spec"] as const, "doc_kind", filePath),
+    id: asString(attributes.id, "id", filePath),
+    title: asString(attributes.title, "title", filePath),
+    summary: asString(attributes.summary, "summary", filePath, "No summary provided."),
+    status: asEnum(attributes.status, SPEC_STATUSES, "status", filePath, "proposed"),
+    taskIds: asStringArray(attributes.task_ids, "task_ids", filePath),
+    tags: asStringArray(attributes.tags, "tags", filePath),
+    owner: asOptionalString(attributes.owner),
+    updatedAt: asOptionalString(attributes.updated_at),
+    body: body.trim(),
+    filePath,
+  };
+}
+
+export function parseTaskDocument(filePath: string, attributes: unknown, body: string): TaskDocument {
+  if (!isRecord(attributes)) {
+    fail(`Invalid frontmatter in ${filePath}`);
+  }
+
+  return {
+    docKind: asEnum(attributes.doc_kind, ["task"] as const, "doc_kind", filePath),
+    id: asString(attributes.id, "id", filePath),
+    title: asString(attributes.title, "title", filePath),
+    summary: asString(attributes.summary, "summary", filePath, "No summary provided."),
+    status: asEnum(attributes.status, TASK_STATUSES, "status", filePath, "todo"),
+    specIds: asStringArray(attributes.spec_ids, "spec_ids", filePath),
+    dependsOn: asStringArray(attributes.depends_on, "depends_on", filePath),
+    blockedBy: asStringArray(attributes.blocked_by, "blocked_by", filePath),
+    priority: asNumber(attributes.priority, "priority", filePath, 3),
+    ownerRole: asOptionalString(attributes.owner_role),
+    createdAt: asOptionalString(attributes.created_at),
+    completedAt: asOptionalString(attributes.completed_at),
+    cancelledAt: asOptionalString(attributes.cancelled_at),
+    archivedAt: asOptionalString(attributes.archived_at),
+    archiveReason: asOptionalString(attributes.archive_reason),
+    tags: asStringArray(attributes.tags, "tags", filePath),
+    updatedAt: asOptionalString(attributes.updated_at),
+    body: body.trim(),
+    filePath,
+  };
+}
+
+export function parseHandoffDocument(filePath: string, attributes: unknown, body: string): HandoffDocument {
+  if (!isRecord(attributes)) {
+    fail(`Invalid frontmatter in ${filePath}`);
+  }
+
+  return {
+    docKind: asEnum(attributes.doc_kind, ["handoff"] as const, "doc_kind", filePath),
+    id: asString(attributes.id, "id", filePath),
+    title: asString(attributes.title, "title", filePath),
+    summary: asString(attributes.summary, "summary", filePath, "No summary provided."),
+    handoffKind: asEnum(attributes.handoff_kind, HANDOFF_KINDS, "handoff_kind", filePath, "checkpoint"),
+    createdAt: asString(attributes.created_at, "created_at", filePath),
+    activeTaskIds: asStringArray(attributes.active_task_ids, "active_task_ids", filePath),
+    relatedSpecIds: asStringArray(attributes.related_spec_ids, "related_spec_ids", filePath),
+    author: asString(attributes.author, "author", filePath, "spec-embryo"),
+    tags: asStringArray(attributes.tags, "tags", filePath),
+    updatedAt: asOptionalString(attributes.updated_at),
+    body: body.trim(),
+    filePath,
+  };
+}
+
+export function parseCurrentStateDocument(filePath: string, attributes: unknown, body: string): CurrentStateDocument {
+  if (!isRecord(attributes)) {
+    fail(`Invalid frontmatter in ${filePath}`);
+  }
+
+  return {
+    docKind: asEnum(attributes.doc_kind, ["current-state"] as const, "doc_kind", filePath),
+    id: asString(attributes.id, "id", filePath, "CURRENT"),
+    title: asString(attributes.title, "title", filePath, "Current Project State"),
+    summary: asString(attributes.summary, "summary", filePath, "Current project state."),
+    focus: asString(attributes.focus, "focus", filePath, "Define the current focus."),
+    activeSpecIds: asStringArray(attributes.active_spec_ids, "active_spec_ids", filePath),
+    activeTaskIds: asStringArray(attributes.active_task_ids, "active_task_ids", filePath),
+    blockedTaskIds: asStringArray(attributes.blocked_task_ids, "blocked_task_ids", filePath),
+    nextActionHints: asStringArray(attributes.next_action_hints, "next_action_hints", filePath),
+    lastHandoffId: asOptionalString(attributes.last_handoff_id),
+    tags: asStringArray(attributes.tags, "tags", filePath),
+    updatedAt: asOptionalString(attributes.updated_at),
+    body: body.trim(),
+    filePath,
+  };
+}

package/src/engine.ts

@@ -0,0 +1,290 @@
+import { relative } from "node:path";
+import type {
+  ChangedItemSummary,
+  CurrentStateDocument,
+  ProjectContext,
+  ResumeContext,
+  SpecDocument,
+  StatusSnapshot,
+  TaskDocument,
+  TaskNodeSummary,
+} from "./domain.ts";
+
+function byPriority(left: TaskDocument, right: TaskDocument): number {
+  return left.priority - right.priority || left.id.localeCompare(right.id);
+}
+
+function unique<T>(items: T[]): T[] {
+  return [...new Set(items)];
+}
+
+function parseGitStatusPath(line: string): string | undefined {
+  if (line.length < 4) {
+    return undefined;
+  }
+
+  const rawPath = line.slice(3).trim();
+  if (rawPath.length === 0) {
+    return undefined;
+  }
+
+  const renameParts = rawPath.split(" -> ");
+  return renameParts[renameParts.length - 1]?.trim() || undefined;
+}
+
+export function buildTaskIndex(tasks: TaskDocument[]): Map<string, TaskDocument> {
+  return new Map(tasks.map((task) => [task.id, task]));
+}
+
+export function summarizeTaskNode(task: TaskDocument, index: Map<string, TaskDocument>): TaskNodeSummary {
+  const unmetDependencies = task.dependsOn.filter((dependencyId) => index.get(dependencyId)?.status !== "done");
+  const downstreamCount = [...index.values()].filter((candidate) => candidate.dependsOn.includes(task.id)).length;
+
+  return {
+    task,
+    unmetDependencies,
+    downstreamCount,
+  };
+}
+
+export function deriveMissingDependencies(tasks: TaskDocument[]): Array<{ taskId: string; missingTaskId: string }> {
+  const index = buildTaskIndex(tasks);
+  return tasks.flatMap((task) =>
+    task.dependsOn
+      .filter((dependencyId) => !index.has(dependencyId))
+      .map((missingTaskId) => ({ taskId: task.id, missingTaskId })),
+  );
+}
+
+export function deriveChangedItems(context: ProjectContext): ChangedItemSummary[] {
+  const specByPath = new Map(context.specs.map((spec) => [relative(context.rootDir, spec.filePath), spec]));
+  const taskByPath = new Map(context.tasks.map((task) => [relative(context.rootDir, task.filePath), task]));
+  const handoffByPath = new Map(context.handoffs.map((handoff) => [relative(context.rootDir, handoff.filePath), handoff]));
+  const currentStatePath = relative(context.rootDir, context.currentState.filePath);
+  const seen = new Set<string>();
+  const items: ChangedItemSummary[] = [];
+
+  for (const line of context.git.shortStatus) {
+    const path = parseGitStatusPath(line);
+    if (!path || seen.has(path)) {
+      continue;
+    }
+
+    seen.add(path);
+
+    const spec = specByPath.get(path);
+    if (spec) {
+      items.push({ kind: "spec", path, id: spec.id, title: spec.title });
+      continue;
+    }
+
+    const task = taskByPath.get(path);
+    if (task) {
+      items.push({ kind: "task", path, id: task.id, title: task.title });
+      continue;
+    }
+
+    if (path === currentStatePath) {
+      items.push({ kind: "current-state", path, id: context.currentState.id, title: context.currentState.title });
+      continue;
+    }
+
+    const handoff = handoffByPath.get(path);
+    if (handoff) {
+      items.push({ kind: "handoff", path, id: handoff.id, title: handoff.title });
+      continue;
+    }
+
+    items.push({ kind: "other", path });
+  }
+
+  return items;
+}
+
+function deriveActiveTaskIds(tasks: TaskDocument[], currentState: CurrentStateDocument): string[] {
+  if (currentState.activeTaskIds.length > 0) {
+    return unique(currentState.activeTaskIds);
+  }
+
+  return tasks.filter((task) => task.status === "in_progress" || task.status === "review").map((task) => task.id);
+}
+
+function deriveActiveSpecIds(specs: SpecDocument[], currentState: CurrentStateDocument, activeTaskIds: string[], taskIndex: Map<string, TaskDocument>): string[] {
+  if (currentState.activeSpecIds.length > 0) {
+    return unique(currentState.activeSpecIds);
+  }
+
+  const inferred = activeTaskIds.flatMap((taskId) => taskIndex.get(taskId)?.specIds ?? []);
+  return unique(specs.filter((spec) => spec.status === "active").map((spec) => spec.id).concat(inferred));
+}
+
+function computeCriticalPath(tasks: TaskDocument[], index: Map<string, TaskDocument>): TaskDocument[] {
+  const unfinished = tasks.filter((task) => task.status !== "done" && task.status !== "cancelled");
+  const cache = new Map<string, TaskDocument[]>();
+
+  function dfs(task: TaskDocument, trail: Set<string>): TaskDocument[] {
+    if (cache.has(task.id)) {
+      return cache.get(task.id)!;
+    }
+
+    if (trail.has(task.id)) {
+      return [task];
+    }
+
+    const nextTrail = new Set(trail);
+    nextTrail.add(task.id);
+
+    let best: TaskDocument[] = [task];
+    for (const dependencyId of task.dependsOn) {
+      const dependency = index.get(dependencyId);
+      if (!dependency || dependency.status === "done" || dependency.status === "cancelled") {
+        continue;
+      }
+
+      const candidate = [...dfs(dependency, nextTrail), task];
+      if (candidate.length > best.length) {
+        best = candidate;
+      }
+    }
+
+    cache.set(task.id, best);
+    return best;
+  }
+
+  let overallBest: TaskDocument[] = [];
+  for (const task of unfinished) {
+    const candidate = dfs(task, new Set());
+    if (candidate.length > overallBest.length) {
+      overallBest = candidate;
+    }
+  }
+
+  return overallBest;
+}
+
+export function deriveStatusSnapshot(context: ProjectContext): StatusSnapshot {
+  const taskIndex = buildTaskIndex(context.tasks);
+  const activeTaskIds = deriveActiveTaskIds(context.tasks, context.currentState);
+  const activeSpecIds = deriveActiveSpecIds(context.specs, context.currentState, activeTaskIds, taskIndex);
+  const activeTasks = activeTaskIds.map((taskId) => taskIndex.get(taskId)).filter((task): task is TaskDocument => Boolean(task));
+  const activeTaskSet = new Set(activeTasks.map((task) => task.id));
+
+  const blockedTasks = context.tasks
+    .filter((task) => task.status === "blocked" || (task.status === "todo" && task.dependsOn.some((dependencyId) => taskIndex.get(dependencyId)?.status !== "done")))
+    .map((task) => summarizeTaskNode(task, taskIndex))
+    .sort((left, right) => byPriority(left.task, right.task));
+
+  const reviewTasks = context.tasks
+    .filter((task) => task.status === "review")
+    .map((task) => summarizeTaskNode(task, taskIndex))
+    .sort((left, right) => byPriority(left.task, right.task));
+
+  const readyTasks = context.tasks
+    .filter((task) => {
+      if (task.status !== "todo") {
+        return false;
+      }
+
+      return summarizeTaskNode(task, taskIndex).unmetDependencies.length === 0;
+    })
+    .filter((task) => !activeTaskSet.has(task.id))
+    .map((task) => summarizeTaskNode(task, taskIndex))
+    .sort((left, right) => byPriority(left.task, right.task));
+
+  return {
+    specCount: context.specs.length,
+    taskCount: context.tasks.length,
+    activeSpecIds,
+    activeTaskIds,
+    blockedTasks,
+    reviewTasks,
+    readyTasks,
+    inProgressTasks: context.tasks.filter((task) => task.status === "in_progress").sort(byPriority),
+    recentHandoff: context.handoffs[0],
+    criticalPath: computeCriticalPath(context.tasks, taskIndex),
+    missingDependencies: deriveMissingDependencies(context.tasks),
+    changedItems: deriveChangedItems(context),
+  };
+}
+
+export function deriveNextActions(context: ProjectContext, snapshot: StatusSnapshot): string[] {
+  const actions: string[] = [];
+
+  if (snapshot.blockedTasks.length > 0) {
+    for (const blocked of snapshot.blockedTasks.slice(0, 2)) {
+      const reason = blocked.unmetDependencies.length > 0 ? `waiting on ${blocked.unmetDependencies.join(", ")}` : "marked blocked";
+      actions.push(`Unblock ${blocked.task.id} (${blocked.task.title}) because it is ${reason}.`);
+    }
+  }
+
+  if (snapshot.inProgressTasks.length > 0) {
+    for (const task of snapshot.inProgressTasks.slice(0, 2)) {
+      actions.push(`Continue ${task.id} (${task.title}) and update the configured current state file when its scope shifts.`);
+    }
+  }
+
+  if (actions.length < 3 && snapshot.reviewTasks.length > 0) {
+    for (const review of snapshot.reviewTasks.slice(0, 3 - actions.length)) {
+      actions.push(`Review ${review.task.id} (${review.task.title}) before moving it to done.`);
+    }
+  }
+
+  if (actions.length < 3 && snapshot.readyTasks.length > 0) {
+    for (const ready of snapshot.readyTasks.slice(0, 3 - actions.length)) {
+      actions.push(`Start ${ready.task.id} (${ready.task.title}); all declared dependencies are satisfied.`);
+    }
+  }
+
+  if (actions.length < 4 && snapshot.changedItems.length > 0) {
+    const changedDocs = snapshot.changedItems
+      .filter((item) => item.kind !== "other")
+      .slice(0, 2)
+      .map((item) => item.id ?? item.path);
+
+    if (changedDocs.length > 0) {
+      actions.push(`Reconcile recent repo changes touching ${changedDocs.join(", ")} before the next checkpoint.`);
+    }
+  }
+
+  if (actions.length === 0) {
+    actions.push("Capture the next meaningful slice in the configured current state file or create a new task.");
+  }
+
+  for (const hint of context.currentState.nextActionHints) {
+    if (actions.length >= 4) {
+      break;
+    }
+
+    actions.push(hint);
+  }
+
+  return unique(actions);
+}
+
+export function buildResumeContext(context: ProjectContext): ResumeContext {
+  const snapshot = deriveStatusSnapshot(context);
+  const taskIndex = buildTaskIndex(context.tasks);
+  const activeSpecs = snapshot.activeSpecIds
+    .map((specId) => context.specs.find((spec) => spec.id === specId))
+    .filter((spec): spec is SpecDocument => Boolean(spec));
+  const activeTasks = snapshot.activeTaskIds
+    .map((taskId) => taskIndex.get(taskId))
+    .filter((task): task is TaskDocument => Boolean(task))
+    .map((task) => summarizeTaskNode(task, taskIndex));
+
+  return {
+    projectName: context.config.projectName,
+    focus: context.currentState.focus,
+    summary: context.currentState.summary,
+    activeSpecs,
+    activeTasks,
+    blockedTasks: snapshot.blockedTasks,
+    reviewTasks: snapshot.reviewTasks,
+    readyTasks: snapshot.readyTasks,
+    criticalPath: snapshot.criticalPath,
+    recentHandoff: snapshot.recentHandoff,
+    nextActions: deriveNextActions(context, snapshot),
+    git: context.git,
+    changedItems: snapshot.changedItems,
+  };
+}