@jmoyers/harness 0.1.0

package/src/mux/live-mux/gateway-status-timeline.ts

@@ -0,0 +1,166 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveStatusTimelineStatePath } from './status-timeline-state.ts';
+
+type GatewayStatusTimelineAction = 'start' | 'stop';
+
+interface RunHarnessStatusTimelineCommandInput {
+  readonly invocationDirectory: string;
+  readonly harnessScriptPath: string;
+  readonly sessionName: string | null;
+  readonly action: GatewayStatusTimelineAction;
+}
+
+interface RunHarnessStatusTimelineCommandResult {
+  readonly stdout: string;
+  readonly stderr: string;
+}
+
+interface ToggleGatewayStatusTimelineOptions {
+  readonly invocationDirectory: string;
+  readonly sessionName: string | null;
+  readonly statusTimelineStateExists?: (statusTimelineStatePath: string) => boolean;
+  readonly runHarnessStatusTimelineCommand?: (
+    input: RunHarnessStatusTimelineCommandInput,
+  ) => Promise<RunHarnessStatusTimelineCommandResult>;
+  readonly harnessScriptPath?: string;
+}
+
+interface ToggleGatewayStatusTimelineResult {
+  readonly action: GatewayStatusTimelineAction;
+  readonly message: string;
+  readonly stdout: string;
+}
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_HARNESS_SCRIPT_PATH = resolve(SCRIPT_DIR, '../../../scripts/harness.ts');
+
+function firstNonEmptyLine(text: string): string | null {
+  const lines = text
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+  return lines[0] ?? null;
+}
+
+function lineValueForPrefix(text: string, prefix: string): string | null {
+  for (const rawLine of text.split('\n')) {
+    const line = rawLine.trim();
+    if (!line.startsWith(prefix)) {
+      continue;
+    }
+    const value = line.slice(prefix.length).trim();
+    if (value.length > 0) {
+      return value;
+    }
+  }
+  return null;
+}
+
+export function resolveHarnessStatusTimelineCommandArgs(
+  action: GatewayStatusTimelineAction,
+  sessionName: string | null,
+): readonly string[] {
+  if (sessionName === null) {
+    return ['status-timeline', action];
+  }
+  return ['--session', sessionName, 'status-timeline', action];
+}
+
+function summarizeStatusTimelineSuccess(
+  action: GatewayStatusTimelineAction,
+  stdout: string,
+): string {
+  if (action === 'start') {
+    const timelinePath = lineValueForPrefix(stdout, 'status-timeline-target:');
+    if (timelinePath !== null) {
+      return `status: timeline=${timelinePath}`;
+    }
+  }
+  const firstLine = firstNonEmptyLine(stdout);
+  if (firstLine !== null) {
+    return firstLine;
+  }
+  if (action === 'start') {
+    return 'status timeline started';
+  }
+  return 'status timeline stopped';
+}
+
+function summarizeStatusTimelineFailure(
+  action: GatewayStatusTimelineAction,
+  stderr: string,
+  stdout: string,
+): string {
+  const detail = firstNonEmptyLine(stderr) ?? firstNonEmptyLine(stdout) ?? 'unknown error';
+  return `status timeline ${action} failed: ${detail}`;
+}
+
+async function runHarnessStatusTimelineCommand(
+  input: RunHarnessStatusTimelineCommandInput,
+): Promise<RunHarnessStatusTimelineCommandResult> {
+  const commandArgs = resolveHarnessStatusTimelineCommandArgs(input.action, input.sessionName);
+  const child = spawn(process.execPath, [input.harnessScriptPath, ...commandArgs], {
+    cwd: input.invocationDirectory,
+    env: {
+      ...process.env,
+      HARNESS_INVOKE_CWD: input.invocationDirectory,
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  const stdoutChunks: Buffer[] = [];
+  const stderrChunks: Buffer[] = [];
+  child.stdout?.on('data', (chunk: Buffer | string) => {
+    stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  });
+  child.stderr?.on('data', (chunk: Buffer | string) => {
+    stderrChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  });
+
+  const [code, signal] = await new Promise<[number | null, NodeJS.Signals | null]>(
+    (resolveExit, rejectExit) => {
+      child.once('error', rejectExit);
+      child.once('exit', (exitCode, exitSignal) => {
+        resolveExit([exitCode, exitSignal]);
+      });
+    },
+  );
+
+  const stdout = Buffer.concat(stdoutChunks).toString('utf8');
+  const stderr = Buffer.concat(stderrChunks).toString('utf8');
+  const exitCode = code ?? (signal === 'SIGINT' ? 130 : signal === 'SIGTERM' ? 143 : 1);
+  if (exitCode !== 0) {
+    throw new Error(summarizeStatusTimelineFailure(input.action, stderr, stdout));
+  }
+
+  return {
+    stdout,
+    stderr,
+  };
+}
+
+export async function toggleGatewayStatusTimeline(
+  options: ToggleGatewayStatusTimelineOptions,
+): Promise<ToggleGatewayStatusTimelineResult> {
+  const statePath = resolveStatusTimelineStatePath(
+    options.invocationDirectory,
+    options.sessionName,
+  );
+  const isRunning = (options.statusTimelineStateExists ?? existsSync)(statePath);
+  const action: GatewayStatusTimelineAction = isRunning ? 'stop' : 'start';
+  const harnessScriptPath = options.harnessScriptPath ?? DEFAULT_HARNESS_SCRIPT_PATH;
+  const runCommand = options.runHarnessStatusTimelineCommand ?? runHarnessStatusTimelineCommand;
+  const result = await runCommand({
+    invocationDirectory: options.invocationDirectory,
+    harnessScriptPath,
+    sessionName: options.sessionName,
+    action,
+  });
+  return {
+    action,
+    message: summarizeStatusTimelineSuccess(action, result.stdout),
+    stdout: result.stdout,
+  };
+}

package/src/mux/live-mux/git-parsing.ts

@@ -0,0 +1,131 @@
+export function parseGitBranchFromStatusHeader(header: string | null): string {
+  if (header === null) {
+    return '(detached)';
+  }
+  const raw = header.trim();
+  if (raw.length === 0) {
+    return '(detached)';
+  }
+  if (raw.startsWith('No commits yet on')) {
+    const branch = raw.slice('No commits yet on'.length).trim();
+    return branch.length > 0 ? branch : '(detached)';
+  }
+  const [headPart = ''] = raw.split('...');
+  const head = headPart.trim();
+  if (head.length === 0 || head === 'HEAD' || head.startsWith('HEAD ')) {
+    return '(detached)';
+  }
+  return head;
+}
+
+export function parseGitShortstatCounts(output: string): { additions: number; deletions: number } {
+  const additionsMatch = output.match(/(\d+)\s+insertions?\(\+\)/);
+  const deletionsMatch = output.match(/(\d+)\s+deletions?\(-\)/);
+  return {
+    additions: additionsMatch === null ? 0 : Number.parseInt(additionsMatch[1]!, 10),
+    deletions: deletionsMatch === null ? 0 : Number.parseInt(deletionsMatch[1]!, 10),
+  };
+}
+
+export function normalizeGitHubRemoteUrl(value: string): string | null {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+
+  const normalizePath = (rawPath: string): string | null => {
+    let path = rawPath.trim().replace(/^\/+/u, '').replace(/\/+$/u, '');
+    if (path.length === 0) {
+      return null;
+    }
+    if (path.endsWith('.git')) {
+      path = path.slice(0, -4);
+    }
+    const [owner = '', repository = ''] = path.split('/');
+    if (owner.length === 0 || repository.length === 0) {
+      return null;
+    }
+    return `https://github.com/${owner.toLowerCase()}/${repository.toLowerCase()}`;
+  };
+
+  const scpMatch = trimmed.match(/^git@github\.com:(.+)$/iu);
+  if (scpMatch !== null) {
+    return normalizePath(scpMatch[1]!);
+  }
+
+  let candidate = trimmed;
+  if (candidate.startsWith('ssh://')) {
+    candidate = `https://${candidate.slice('ssh://'.length)}`;
+  } else if (candidate.startsWith('git://')) {
+    candidate = `https://${candidate.slice('git://'.length)}`;
+  }
+
+  let parsed: URL;
+  try {
+    parsed = new URL(candidate);
+  } catch {
+    return null;
+  }
+  if (parsed.hostname.toLowerCase() !== 'github.com') {
+    return null;
+  }
+  return normalizePath(parsed.pathname);
+}
+
+export function repositoryNameFromGitHubRemoteUrl(remoteUrl: string): string {
+  const normalized = normalizeGitHubRemoteUrl(remoteUrl);
+  if (normalized === null) {
+    return remoteUrl;
+  }
+  const parts = normalized.split('/');
+  const name = parts[parts.length - 1]!;
+  return name;
+}
+
+export function shouldShowGitHubPrActions(input: {
+  trackedBranch: string | null;
+  defaultBranch: string | null;
+}): boolean {
+  const trackedBranch = input.trackedBranch?.trim() ?? '';
+  if (trackedBranch.length === 0 || trackedBranch === '(detached)') {
+    return false;
+  }
+  const normalizedTrackedBranch = trackedBranch.toLowerCase();
+  const normalizedDefaultBranch = input.defaultBranch?.trim().toLowerCase() ?? '';
+  if (normalizedDefaultBranch.length > 0) {
+    return normalizedTrackedBranch !== normalizedDefaultBranch;
+  }
+  return normalizedTrackedBranch !== 'main';
+}
+
+export function parseCommitCount(output: string): number | null {
+  const trimmed = output.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  const parsed = Number.parseInt(trimmed, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return null;
+  }
+  return parsed;
+}
+
+export function parseLastCommitLine(output: string): {
+  lastCommitAt: string | null;
+  shortCommitHash: string | null;
+} {
+  const trimmed = output.trim();
+  if (trimmed.length === 0) {
+    return {
+      lastCommitAt: null,
+      shortCommitHash: null,
+    };
+  }
+  const [hashPart = '', tsPart = ''] = trimmed.split('\t');
+  const hash = hashPart.trim();
+  const timestamp = tsPart.trim();
+  return {
+    lastCommitAt: timestamp.length > 0 ? timestamp : null,
+    shortCommitHash: hash,
+  };
+}

package/src/mux/live-mux/git-snapshot.ts

@@ -0,0 +1,263 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import {
+  normalizeGitHubRemoteUrl,
+  parseCommitCount,
+  parseGitBranchFromStatusHeader,
+  parseGitShortstatCounts,
+  parseLastCommitLine,
+  repositoryNameFromGitHubRemoteUrl,
+} from './git-parsing.ts';
+
+const execFileAsync = promisify(execFile);
+
+interface GitSummary {
+  readonly branch: string;
+  readonly changedFiles: number;
+  readonly additions: number;
+  readonly deletions: number;
+}
+
+interface GitRepositorySnapshot {
+  readonly normalizedRemoteUrl: string | null;
+  readonly commitCount: number | null;
+  readonly lastCommitAt: string | null;
+  readonly shortCommitHash: string | null;
+  readonly inferredName: string | null;
+  readonly defaultBranch: string | null;
+}
+
+interface GitDirectorySnapshot {
+  readonly summary: GitSummary;
+  readonly repository: GitRepositorySnapshot;
+}
+
+interface ReadGitDirectorySnapshotOptions {
+  readonly includeCommitCount?: boolean;
+}
+
+interface ProcessUsageSample {
+  readonly cpuPercent: number | null;
+  readonly memoryMb: number | null;
+}
+
+export const GIT_SUMMARY_NOT_REPOSITORY: GitSummary = {
+  branch: '(not git)',
+  changedFiles: 0,
+  additions: 0,
+  deletions: 0,
+};
+
+export const GIT_REPOSITORY_NONE: GitRepositorySnapshot = {
+  normalizedRemoteUrl: null,
+  commitCount: null,
+  lastCommitAt: null,
+  shortCommitHash: null,
+  inferredName: null,
+  defaultBranch: null,
+};
+
+interface ExecFileResult {
+  readonly stdout: string;
+}
+
+interface GitProcessRunnerOptions {
+  readonly cwd: string;
+  readonly encoding: 'utf8';
+  readonly timeout: number;
+  readonly maxBuffer: number;
+}
+
+interface PsProcessRunnerOptions {
+  readonly encoding: 'utf8';
+  readonly timeout: number;
+  readonly maxBuffer: number;
+}
+
+export type GitProcessRunner = (
+  command: string,
+  args: readonly string[],
+  options: GitProcessRunnerOptions,
+) => Promise<ExecFileResult>;
+
+export type PsProcessRunner = (
+  command: string,
+  args: readonly string[],
+  options: PsProcessRunnerOptions,
+) => Promise<ExecFileResult>;
+
+export type GitCommandRunner = (cwd: string, args: readonly string[]) => Promise<string>;
+
+const defaultGitProcessRunner: GitProcessRunner = async (command, args, options) => {
+  const result = await execFileAsync(command, [...args], options);
+  return {
+    stdout: result.stdout,
+  };
+};
+
+const defaultPsProcessRunner: PsProcessRunner = async (command, args, options) => {
+  const result = await execFileAsync(command, [...args], options);
+  return {
+    stdout: result.stdout,
+  };
+};
+
+export async function runGitCommand(
+  cwd: string,
+  args: readonly string[],
+  processRunner: GitProcessRunner = defaultGitProcessRunner,
+): Promise<string> {
+  try {
+    const result = await processRunner('git', args, {
+      cwd,
+      encoding: 'utf8',
+      timeout: 1500,
+      maxBuffer: 1024 * 1024,
+    });
+    return result.stdout.trim();
+  } catch {
+    return '';
+  }
+}
+
+async function readNormalizedGitHubRemoteUrl(
+  cwd: string,
+  runCommand: GitCommandRunner,
+): Promise<string | null> {
+  const originRemoteUrl = normalizeGitHubRemoteUrl(
+    await runCommand(cwd, ['remote', 'get-url', 'origin']),
+  );
+  if (originRemoteUrl !== null) {
+    return originRemoteUrl;
+  }
+
+  const remoteNames = (await runCommand(cwd, ['remote']))
+    .split('\n')
+    .map((name) => name.trim())
+    .filter((name) => name.length > 0);
+  for (const remoteName of remoteNames) {
+    const remoteUrl = normalizeGitHubRemoteUrl(
+      await runCommand(cwd, ['remote', 'get-url', remoteName]),
+    );
+    if (remoteUrl !== null) {
+      return remoteUrl;
+    }
+  }
+  return null;
+}
+
+export async function readGitDirectorySnapshot(
+  cwd: string,
+  runCommand: GitCommandRunner = runGitCommand,
+  options: ReadGitDirectorySnapshotOptions = {},
+): Promise<GitDirectorySnapshot> {
+  const insideWorkTree = await runCommand(cwd, ['rev-parse', '--is-inside-work-tree']);
+  if (insideWorkTree !== 'true') {
+    return {
+      summary: GIT_SUMMARY_NOT_REPOSITORY,
+      repository: GIT_REPOSITORY_NONE,
+    };
+  }
+
+  const statusOutputPromise = runCommand(cwd, ['status', '--porcelain=1', '--branch']);
+  const unstagedShortstatPromise = runCommand(cwd, ['diff', '--shortstat']);
+  const stagedShortstatPromise = runCommand(cwd, ['diff', '--cached', '--shortstat']);
+  const remoteUrlPromise = readNormalizedGitHubRemoteUrl(cwd, runCommand);
+  const lastCommitPromise = runCommand(cwd, ['log', '-1', '--format=%ct %h']);
+  const commitCountPromise =
+    options.includeCommitCount === false
+      ? Promise.resolve('')
+      : runCommand(cwd, ['rev-list', '--count', 'HEAD']);
+
+  const statusOutput = await statusOutputPromise;
+  const statusLines = statusOutput.split('\n').filter((line) => line.trim().length > 0);
+  const firstStatusLine = statusLines[0];
+  const headerLine =
+    firstStatusLine !== undefined && firstStatusLine.startsWith('## ')
+      ? statusLines.shift()!.slice(3)
+      : null;
+  const branch = parseGitBranchFromStatusHeader(headerLine);
+  const changedFiles = statusLines.length;
+
+  const [unstagedShortstat, stagedShortstat, remoteUrlRaw, commitCountRaw, lastCommitRaw] =
+    await Promise.all([
+      unstagedShortstatPromise,
+      stagedShortstatPromise,
+      remoteUrlPromise,
+      commitCountPromise,
+      lastCommitPromise,
+    ]);
+
+  const unstaged = parseGitShortstatCounts(unstagedShortstat);
+  const staged = parseGitShortstatCounts(stagedShortstat);
+  const normalizedRemoteUrl = remoteUrlRaw;
+  const commitCount = parseCommitCount(commitCountRaw);
+  const lastCommit = parseLastCommitLine(lastCommitRaw);
+
+  return {
+    summary: {
+      branch,
+      changedFiles,
+      additions: unstaged.additions + staged.additions,
+      deletions: unstaged.deletions + staged.deletions,
+    },
+    repository: {
+      normalizedRemoteUrl,
+      commitCount,
+      lastCommitAt: lastCommit.lastCommitAt,
+      shortCommitHash: lastCommit.shortCommitHash,
+      inferredName:
+        normalizedRemoteUrl === null
+          ? null
+          : repositoryNameFromGitHubRemoteUrl(normalizedRemoteUrl),
+      defaultBranch: branch === '(detached)' ? null : branch,
+    },
+  };
+}
+
+export async function readProcessUsageSample(
+  processId: number | null,
+  processRunner: PsProcessRunner = defaultPsProcessRunner,
+): Promise<ProcessUsageSample> {
+  if (processId === null) {
+    return {
+      cpuPercent: null,
+      memoryMb: null,
+    };
+  }
+
+  let stdout = '';
+  try {
+    const result = await processRunner('ps', ['-p', String(processId), '-o', '%cpu=,rss='], {
+      encoding: 'utf8',
+      timeout: 1000,
+      maxBuffer: 8 * 1024,
+    });
+    stdout = result.stdout;
+  } catch {
+    return {
+      cpuPercent: null,
+      memoryMb: null,
+    };
+  }
+
+  const line = stdout
+    .split('\n')
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0)
+    .at(-1);
+  if (line === undefined) {
+    return {
+      cpuPercent: null,
+      memoryMb: null,
+    };
+  }
+
+  const parts = line.split(/\s+/);
+  const cpuPercentRaw = Number.parseFloat(String(parts[0]));
+  const memoryKbRaw = Number.parseInt(String(parts[1]), 10);
+  return {
+    cpuPercent: Number.isFinite(cpuPercentRaw) ? cpuPercentRaw : null,
+    memoryMb: Number.isFinite(memoryKbRaw) ? memoryKbRaw / 1024 : null,
+  };
+}

package/src/mux/live-mux/git-state.ts

@@ -0,0 +1,136 @@
+import type { StreamObservedEvent } from '../../control-plane/stream-protocol.ts';
+
+export interface GitSummary {
+  readonly branch: string;
+  readonly changedFiles: number;
+  readonly additions: number;
+  readonly deletions: number;
+}
+
+export interface GitRepositorySnapshot {
+  readonly normalizedRemoteUrl: string | null;
+  readonly commitCount: number | null;
+  readonly lastCommitAt: string | null;
+  readonly shortCommitHash: string | null;
+  readonly inferredName: string | null;
+  readonly defaultBranch: string | null;
+}
+
+function gitSummaryEqual(left: GitSummary, right: GitSummary): boolean {
+  return (
+    left.branch === right.branch &&
+    left.changedFiles === right.changedFiles &&
+    left.additions === right.additions &&
+    left.deletions === right.deletions
+  );
+}
+
+function gitRepositorySnapshotEqual(
+  left: GitRepositorySnapshot,
+  right: GitRepositorySnapshot,
+): boolean {
+  return (
+    left.normalizedRemoteUrl === right.normalizedRemoteUrl &&
+    left.commitCount === right.commitCount &&
+    left.lastCommitAt === right.lastCommitAt &&
+    left.shortCommitHash === right.shortCommitHash &&
+    left.defaultBranch === right.defaultBranch &&
+    left.inferredName === right.inferredName
+  );
+}
+
+export function deleteDirectoryGitState(
+  directoryId: string,
+  gitSummaryByDirectoryId: Map<string, GitSummary>,
+  directoryRepositorySnapshotByDirectoryId: Map<string, GitRepositorySnapshot>,
+  repositoryAssociationByDirectoryId: Map<string, string>,
+): void {
+  gitSummaryByDirectoryId.delete(directoryId);
+  directoryRepositorySnapshotByDirectoryId.delete(directoryId);
+  repositoryAssociationByDirectoryId.delete(directoryId);
+}
+
+interface ApplyObservedGitStatusEventOptions<TRepositoryRecord extends { repositoryId: string }> {
+  enabled: boolean;
+  observed: StreamObservedEvent;
+  gitSummaryByDirectoryId: Map<string, GitSummary>;
+  loadingSummary: GitSummary;
+  directoryRepositorySnapshotByDirectoryId: Map<string, GitRepositorySnapshot>;
+  emptyRepositorySnapshot: GitRepositorySnapshot;
+  repositoryAssociationByDirectoryId: Map<string, string>;
+  repositories: Map<string, TRepositoryRecord>;
+  parseRepositoryRecord: (input: unknown) => TRepositoryRecord | null;
+  repositoryRecordChanged: (
+    previous: TRepositoryRecord | undefined,
+    next: TRepositoryRecord,
+  ) => boolean;
+}
+
+interface ApplyObservedGitStatusEventResult {
+  readonly handled: boolean;
+  readonly changed: boolean;
+  readonly repositoryRecordChanged: boolean;
+}
+
+export function applyObservedGitStatusEvent<TRepositoryRecord extends { repositoryId: string }>(
+  options: ApplyObservedGitStatusEventOptions<TRepositoryRecord>,
+): ApplyObservedGitStatusEventResult {
+  const {
+    enabled,
+    observed,
+    gitSummaryByDirectoryId,
+    loadingSummary,
+    directoryRepositorySnapshotByDirectoryId,
+    emptyRepositorySnapshot,
+    repositoryAssociationByDirectoryId,
+    repositories,
+    parseRepositoryRecord,
+    repositoryRecordChanged,
+  } = options;
+  if (!enabled || observed.type !== 'directory-git-updated') {
+    return {
+      handled: false,
+      changed: false,
+      repositoryRecordChanged: false,
+    };
+  }
+
+  const previousSummary = gitSummaryByDirectoryId.get(observed.directoryId) ?? loadingSummary;
+  const summaryChanged = !gitSummaryEqual(previousSummary, observed.summary);
+  gitSummaryByDirectoryId.set(observed.directoryId, observed.summary);
+
+  const previousRepositorySnapshot =
+    directoryRepositorySnapshotByDirectoryId.get(observed.directoryId) ?? emptyRepositorySnapshot;
+  const repositorySnapshotChanged = !gitRepositorySnapshotEqual(
+    previousRepositorySnapshot,
+    observed.repositorySnapshot,
+  );
+  directoryRepositorySnapshotByDirectoryId.set(observed.directoryId, observed.repositorySnapshot);
+
+  let associationChanged = false;
+  if (observed.repositoryId === null) {
+    associationChanged = repositoryAssociationByDirectoryId.delete(observed.directoryId);
+  } else {
+    const previousRepositoryId =
+      repositoryAssociationByDirectoryId.get(observed.directoryId) ?? null;
+    repositoryAssociationByDirectoryId.set(observed.directoryId, observed.repositoryId);
+    associationChanged = previousRepositoryId !== observed.repositoryId;
+  }
+
+  let changedRepositoryRecord = false;
+  if (observed.repository !== null) {
+    const repository = parseRepositoryRecord(observed.repository);
+    if (repository !== null) {
+      const previous = repositories.get(repository.repositoryId);
+      repositories.set(repository.repositoryId, repository);
+      changedRepositoryRecord = repositoryRecordChanged(previous, repository);
+    }
+  }
+
+  return {
+    handled: true,
+    changed:
+      summaryChanged || repositorySnapshotChanged || associationChanged || changedRepositoryRecord,
+    repositoryRecordChanged: changedRepositoryRecord,
+  };
+}