@flyingrobots/graft 0.7.0 → 0.7.1

package/src/adapters/canonical-json.ts

@@ -1,56 +0,0 @@
-// ---------------------------------------------------------------------------
-// CanonicalJsonCodec — deterministic JSON with sorted keys
-// ---------------------------------------------------------------------------
-//
-// Subset of RFC 8785 (JSON Canonicalization Scheme):
-//   - Object keys sorted lexicographically at every nesting level
-//   - Compact output (no whitespace)
-//   - Deterministic: same data always produces the same string
-//
-// Enables stable hashes, diffable logs, reproducible receipts.
-// ---------------------------------------------------------------------------
-
-import type { JsonCodec } from "../ports/codec.js";
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(value) as unknown;
-  return proto === Object.prototype || proto === null;
-}
-
-function sortDeep(value: unknown, seen = new WeakSet()): unknown {
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  if (!isPlainObject(value) && !Array.isArray(value)) {
-    return value;
-  }
-  if (seen.has(value)) {
-    throw new TypeError("Converting circular structure to JSON");
-  }
-  seen.add(value);
-  try {
-    if (Array.isArray(value)) {
-      return value.map((v) => sortDeep(v, seen));
-    }
-    const sorted: Record<string, unknown> = {};
-    for (const key of Object.keys(value).sort()) {
-      sorted[key] = sortDeep(value[key], seen);
-    }
-    return sorted;
-  } finally {
-    seen.delete(value);
-  }
-}
-
-export class CanonicalJsonCodec implements JsonCodec {
-  encode(value: unknown): string {
-    return JSON.stringify(sortDeep(value));
-  }
-
-  decode(data: string): unknown {
-    return JSON.parse(data) as unknown;
-  }
-}

package/src/adapters/json-text-decoder.ts

@@ -1,11 +0,0 @@
-import { type JsonObject, parseJsonObject } from "../contracts/json-object.js";
-
-export function parseJsonTextObject(text: string, label: string): JsonObject {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(text) as unknown;
-  } catch {
-    throw new Error(`${label} was not valid JSON`);
-  }
-  return parseJsonObject(parsed, label);
-}

package/src/adapters/node-fs.ts

@@ -1,43 +0,0 @@
-// ---------------------------------------------------------------------------
-// Node.js filesystem adapter — implements the FileSystem port
-// ---------------------------------------------------------------------------
-
-import * as fs from "node:fs";
-import * as fsp from "node:fs/promises";
-import type { FileSystem } from "../ports/filesystem.js";
-
-class NodeFileSystem implements FileSystem {
-  readFile(path: string, encoding: "utf-8"): Promise<string>;
-  readFile(path: string): Promise<Buffer>;
-  readFile(path: string, encoding?: "utf-8"): Promise<string | Buffer> {
-    if (encoding !== undefined) return fsp.readFile(path, encoding);
-    return fsp.readFile(path);
-  }
-
-  readdir(path: string): Promise<string[]> {
-    return fsp.readdir(path);
-  }
-
-  writeFile(path: string, data: string, encoding: "utf-8"): Promise<void> {
-    return fsp.writeFile(path, data, encoding);
-  }
-
-  appendFile(path: string, data: string, encoding: "utf-8"): Promise<void> {
-    return fsp.appendFile(path, data, encoding);
-  }
-
-  async mkdir(path: string, options: { recursive: true }): Promise<void> {
-    await fsp.mkdir(path, options);
-  }
-
-  async stat(path: string): Promise<{ size: number }> {
-    const s = await fsp.stat(path);
-    return { size: s.size };
-  }
-
-  readFileSync(path: string, encoding: "utf-8"): string {
-    return fs.readFileSync(path, encoding);
-  }
-}
-
-export const nodeFs: FileSystem = new NodeFileSystem();

package/src/adapters/node-git.ts

@@ -1,47 +0,0 @@
-// ---------------------------------------------------------------------------
-// NodeGitClient — implements the GitClient port via GitPlumbing
-// ---------------------------------------------------------------------------
-
-import GitPlumbing from "@git-stunts/plumbing";
-import type { GitClient, GitRunRequest } from "../ports/git.js";
-
-class NodeGitClient implements GitClient {
-  private readonly clients = new Map<string, GitPlumbing>();
-
-  private resolveClient(cwd: string): GitPlumbing {
-    const cached = this.clients.get(cwd);
-    if (cached !== undefined) return cached;
-    const created = GitPlumbing.createDefault({ cwd });
-    this.clients.set(cwd, created);
-    return created;
-  }
-
-  async run(request: GitRunRequest) {
-    try {
-      const plumbing = this.resolveClient(request.cwd);
-      const stream = await plumbing.executeStream({ args: [...request.args] });
-      const stdout = await stream.collect({
-        asString: true,
-        ...(request.maxBufferBytes !== undefined ? { maxBytes: request.maxBufferBytes } : {}),
-      });
-      const finished = await stream.finished;
-      const error = "error" in finished && finished.error instanceof Error ? finished.error : undefined;
-      return {
-        status: finished.code,
-        stdout: typeof stdout === "string" ? stdout : new TextDecoder().decode(stdout),
-        stderr: finished.stderr,
-        ...(error !== undefined ? { error } : {}),
-      };
-    } catch (error: unknown) {
-      const normalized = error instanceof Error ? error : new Error(String(error));
-      return {
-        status: 1,
-        stdout: "",
-        stderr: normalized.message,
-        error: normalized,
-      };
-    }
-  }
-}
-
-export const nodeGit: GitClient = new NodeGitClient();

package/src/adapters/node-paths.ts

@@ -1,35 +0,0 @@
-// ---------------------------------------------------------------------------
-// Node PathOps adapter — implements PathOps using node:path
-// ---------------------------------------------------------------------------
-
-import * as path from "node:path";
-import type { PathOps } from "../ports/paths.js";
-
-function toForwardSlash(p: string): string {
-  return p.replaceAll("\\", "/");
-}
-
-function stripTrailingSlash(p: string): string {
-  if (p === "/") return p;
-  return p.endsWith("/") ? p.slice(0, -1) : p;
-}
-
-function normalizeImpl(p: string): string {
-  return stripTrailingSlash(toForwardSlash(path.normalize(p)));
-}
-
-export const nodePathOps: PathOps = {
-  normalize(p: string): string {
-    return normalizeImpl(p);
-  },
-
-  isWithin(filePath: string, directory: string): boolean {
-    const normFile = normalizeImpl(filePath);
-    const normDir = normalizeImpl(directory);
-    return normFile === normDir || normFile.startsWith(`${normDir}/`);
-  },
-
-  join(...segments: string[]): string {
-    return normalizeImpl(path.join(...segments));
-  },
-};

package/src/adapters/node-process-runner.ts

@@ -1,27 +0,0 @@
-// ---------------------------------------------------------------------------
-// NodeProcessRunner — implements the ProcessRunner port
-// ---------------------------------------------------------------------------
-
-import { spawnSync } from "node:child_process";
-import type { ProcessRunRequest, ProcessRunResult, ProcessRunner } from "../ports/process-runner.js";
-
-class NodeProcessRunner implements ProcessRunner {
-  run(request: ProcessRunRequest): ProcessRunResult {
-    const result = spawnSync(request.command, [...request.args], {
-      cwd: request.cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      ...(request.timeoutMs !== undefined ? { timeout: request.timeoutMs } : {}),
-      ...(request.maxBufferBytes !== undefined ? { maxBuffer: request.maxBufferBytes } : {}),
-    });
-
-    return {
-      status: result.status,
-      stdout: typeof result.stdout === "string" ? result.stdout : "",
-      stderr: typeof result.stderr === "string" ? result.stderr : "",
-      ...(result.error !== undefined ? { error: result.error } : {}),
-    };
-  }
-}
-
-export const nodeProcessRunner: ProcessRunner = new NodeProcessRunner();

package/src/adapters/repo-paths.ts

@@ -1,63 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-function pathEscapesRoot(root: string, target: string): boolean {
-  const relative = path.relative(root, target);
-  return relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative);
-}
-
-function realPathOrSelf(target: string): string {
-  try {
-    return fs.realpathSync.native(target);
-  } catch {
-    return target;
-  }
-}
-
-function nearestExistingAncestor(target: string): string {
-  let current = target;
-  while (current.length > 0) {
-    try {
-      fs.lstatSync(current);
-      return current;
-    } catch {
-      const parent = path.dirname(current);
-      if (parent === current) {
-        return current;
-      }
-      current = parent;
-    }
-  }
-  return target;
-}
-
-export function createRepoPathResolver(projectRoot: string): (input: string) => string {
-  const normalizedRoot = path.resolve(projectRoot);
-  const realProjectRoot = realPathOrSelf(normalizedRoot);
-
-  return (input: string): string => {
-    const resolved = path.isAbsolute(input)
-      ? path.resolve(input)
-      : path.resolve(normalizedRoot, input);
-
-    if (pathEscapesRoot(normalizedRoot, resolved)) {
-      throw new Error(`Path traversal blocked: ${input}`);
-    }
-
-    const realAncestor = realPathOrSelf(nearestExistingAncestor(resolved));
-    if (pathEscapesRoot(realProjectRoot, realAncestor)) {
-      throw new Error(`Path traversal blocked: ${input}`);
-    }
-
-    return resolved;
-  };
-}
-
-export function toRepoPolicyPath(projectRoot: string, filePath: string): string {
-  const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(projectRoot, filePath);
-  const relativePath = path.relative(projectRoot, absolutePath);
-  if (relativePath.length === 0 || relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
-    return absolutePath;
-  }
-  return relativePath.split(path.sep).join("/");
-}

package/src/adapters/rotating-ndjson-log.ts

@@ -1,66 +0,0 @@
-import * as path from "node:path";
-import type { JsonCodec } from "../ports/codec.js";
-import type { FileSystem } from "../ports/filesystem.js";
-
-export interface RotatingNdjsonLogOptions {
-  readonly fs: FileSystem;
-  readonly codec: JsonCodec;
-  readonly logPath: string;
-  readonly maxBytes?: number;
-}
-
-const DEFAULT_MAX_BYTES = 1_048_576;
-
-export class RotatingNdjsonLog {
-  private readonly fs: FileSystem;
-  private readonly codec: JsonCodec;
-  private readonly logPath: string;
-  private readonly maxBytes: number;
-
-  constructor(options: RotatingNdjsonLogOptions) {
-    this.fs = options.fs;
-    this.codec = options.codec;
-    this.logPath = options.logPath;
-    this.maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
-  }
-
-  async append(entry: object): Promise<void> {
-    const line = this.codec.encode(entry) + "\n";
-    const dir = path.dirname(this.logPath);
-    await this.fs.mkdir(dir, { recursive: true });
-    await this.fs.appendFile(this.logPath, line, "utf-8");
-    await this.rotateIfNeeded();
-  }
-
-  private async rotateIfNeeded(): Promise<void> {
-    let stat: { size: number };
-    try {
-      stat = await this.fs.stat(this.logPath);
-    } catch {
-      return;
-    }
-
-    if (stat.size <= this.maxBytes) {
-      return;
-    }
-
-    const content = await this.fs.readFile(this.logPath, "utf-8");
-    const lines = content.trimEnd().split("\n");
-    let kept = lines.slice(Math.ceil(lines.length / 2));
-
-    // If slicing left nothing (e.g. a single oversized entry), skip rotation —
-    // the file is already at minimum size (one entry).
-    if (kept.length === 0) {
-      return;
-    }
-
-    let result = kept.join("\n") + "\n";
-
-    while (Buffer.byteLength(result, "utf-8") > this.maxBytes && kept.length > 1) {
-      kept = kept.slice(Math.ceil(kept.length / 2));
-      result = kept.join("\n") + "\n";
-    }
-
-    await this.fs.writeFile(this.logPath, result, "utf-8");
-  }
-}

package/src/api/index.ts

@@ -1,107 +0,0 @@
-import { startDaemonServer } from "../mcp/daemon-server.js";
-import { MCP_TOOL_NAMES } from "../contracts/capabilities.js";
-import { createGraftServer } from "../mcp/server.js";
-import { startStdioServer } from "../mcp/stdio-server.js";
-import { ObservationCache } from "../operations/observation-cache.js";
-import { RepoWorkspace } from "../operations/repo-workspace.js";
-import { StructuredBuffer } from "../operations/structured-buffer.js";
-import type { BufferRange, WarmProjectionBasis, WarmProjectionBundleResult } from "../operations/structured-buffer.js";
-import { GRAFT_VERSION } from "../version.js";
-export { createRepoLocalGraft, type CreateRepoLocalGraftOptions } from "./repo-local-graft.js";
-export { createRepoWorkspace, type CreateRepoWorkspaceOptions } from "./repo-workspace.js";
-export { callGraftTool, parseGraftToolPayload } from "./tool-bridge.js";
-
-export interface CreateStructuredBufferOptions {
-  readonly basis?: WarmProjectionBasis | undefined;
-}
-
-export interface CreateProjectionBundleOptions extends CreateStructuredBufferOptions {
-  readonly viewport?: BufferRange | undefined;
-}
-
-export function createStructuredBuffer(
-  path: string,
-  content: string,
-  options: CreateStructuredBufferOptions = {},
-): StructuredBuffer {
-  return new StructuredBuffer({ path, content, basis: options.basis });
-}
-
-export function createProjectionBundle(
-  path: string,
-  content: string,
-  options: CreateProjectionBundleOptions = {},
-): WarmProjectionBundleResult {
-  const buffer = new StructuredBuffer({ path, content, basis: options.basis });
-  try {
-    return buffer.projectionBundle({ viewport: options.viewport });
-  } finally {
-    buffer.dispose();
-  }
-}
-
-export {
-  GRAFT_VERSION,
-  MCP_TOOL_NAMES,
-  ObservationCache,
-  RepoWorkspace,
-  StructuredBuffer,
-  createGraftServer,
-  startDaemonServer,
-  startStdioServer,
-};
-
-export type {
-  AnchorAffinityResult,
-  BufferDiagnostic,
-  BufferOutlineResult,
-  BufferPoint,
-  BufferRange,
-  BufferSelection,
-  ChangedRegion,
-  DiagnosticsResult,
-  FoldRegion,
-  FoldRegionsResult,
-  InjectionRegion,
-  InjectionResult,
-  NodeLookupResult,
-  NodeSummary,
-  RenameEditPreview,
-  RenamePreviewResult,
-  SelectionStepResult,
-  SemanticSummaryKind,
-  SemanticSummaryResult,
-  StructuredBufferDiffResult,
-  SymbolOccurrence,
-  SymbolOccurrencesResult,
-  SyntaxClass,
-  SyntaxSpan,
-  SyntaxSpanResult,
-  WarmProjectionBundleResult,
-  WarmProjectionParseStatus,
-  WarmProjectionBasis,
-} from "../operations/structured-buffer.js";
-
-export type {
-  StartDaemonServerOptions,
-} from "../mcp/daemon-server.js";
-
-export type {
-  CreateGraftServerOptions,
-  GraftServer,
-  McpToolResult,
-} from "../mcp/server.js";
-
-export type {
-  McpToolName,
-} from "../contracts/capabilities.js";
-
-export type {
-  RepoWorkspaceChangedSinceResult,
-  RepoWorkspaceFileOutlineResult,
-  RepoWorkspaceReadRangeResult,
-  RepoWorkspaceRefusedResult,
-  RepoWorkspaceSafeReadCacheHitResult,
-  RepoWorkspaceSafeReadDiffResult,
-  RepoWorkspaceSafeReadResult,
-} from "../operations/repo-workspace.js";

package/src/api/repo-local-graft.ts

@@ -1,21 +0,0 @@
-import * as path from "node:path";
-import {
-  createGraftServer,
-  type CreateGraftServerOptions,
-  type GraftServer,
-} from "../mcp/server.js";
-
-export interface CreateRepoLocalGraftOptions extends Omit<CreateGraftServerOptions, "mode" | "projectRoot" | "graftDir"> {
-  readonly cwd?: string | undefined;
-  readonly graftDir?: string | undefined;
-}
-
-export function createRepoLocalGraft(options: CreateRepoLocalGraftOptions = {}): GraftServer {
-  const cwd = path.resolve(options.cwd ?? process.cwd());
-  return createGraftServer({
-    ...options,
-    mode: "repo_local",
-    projectRoot: cwd,
-    graftDir: options.graftDir ?? path.join(cwd, ".graft"),
-  });
-}

package/src/api/repo-workspace.ts

@@ -1,34 +0,0 @@
-import * as path from "node:path";
-import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
-import { nodeFs } from "../adapters/node-fs.js";
-import { createRepoPathResolver, toRepoPolicyPath } from "../adapters/repo-paths.js";
-import { ObservationCache } from "../operations/observation-cache.js";
-import { RepoWorkspace } from "../operations/repo-workspace.js";
-import { GovernorTracker } from "../session/tracker.js";
-import type { JsonCodec } from "../ports/codec.js";
-import type { FileSystem } from "../ports/filesystem.js";
-
-export interface CreateRepoWorkspaceOptions {
-  readonly cwd?: string | undefined;
-  readonly graftignorePatterns?: readonly string[] | undefined;
-  readonly fs?: FileSystem | undefined;
-  readonly codec?: JsonCodec | undefined;
-  readonly governor?: GovernorTracker | undefined;
-  readonly cache?: ObservationCache | undefined;
-}
-
-export async function createRepoWorkspace(options: CreateRepoWorkspaceOptions = {}): Promise<RepoWorkspace> {
-  const cwd = path.resolve(options.cwd ?? process.cwd());
-  const fs = options.fs ?? nodeFs;
-  const codec = options.codec ?? new CanonicalJsonCodec();
-  return new RepoWorkspace({
-    projectRoot: cwd,
-    fs,
-    codec,
-    graftignorePatterns: options.graftignorePatterns ?? await RepoWorkspace.loadGraftignorePatterns(fs, cwd),
-    resolvePath: createRepoPathResolver(cwd),
-    toPolicyPath: (resolvedPath) => toRepoPolicyPath(cwd, resolvedPath),
-    ...(options.governor !== undefined ? { governor: options.governor } : {}),
-    ...(options.cache !== undefined ? { cache: options.cache } : {}),
-  });
-}

package/src/api/tool-bridge.ts

@@ -1,22 +0,0 @@
-import type { McpToolName } from "../contracts/capabilities.js";
-import type { JsonObject } from "../contracts/json-object.js";
-import { parseJsonTextObject } from "../adapters/json-text-decoder.js";
-import { getMcpOutputSchema, type McpOutputFor } from "../contracts/output-schemas.js";
-import type { GraftServer, McpToolResult } from "../mcp/server.js";
-
-export function parseGraftToolPayload(result: McpToolResult): JsonObject {
-  const payload = result.content.find((item) => item.type === "text");
-  if (payload === undefined) {
-    throw new Error("Graft tool result did not contain a text payload");
-  }
-  return parseJsonTextObject(payload.text, "Graft tool result");
-}
-
-export async function callGraftTool<K extends McpToolName>(
-  graft: GraftServer,
-  name: K,
-  args: JsonObject,
-): Promise<McpOutputFor<K>> {
-  const parsed = parseGraftToolPayload(await graft.callTool(name, args));
-  return getMcpOutputSchema(name).parse(parsed) as McpOutputFor<K>;
-}

package/src/cli/activity-render.ts

@@ -1,112 +0,0 @@
-import { type z } from "zod";
-import { DIAG_ACTIVITY_CLI_SCHEMA } from "../contracts/output-schemas.js";
-
-type DiagActivityOutput = z.infer<typeof DIAG_ACTIVITY_CLI_SCHEMA>;
-type ActivityGroup = DiagActivityOutput["activityWindow"]["groups"][number];
-type ActivityItem = ActivityGroup["items"][number];
-type AttributionSummary = ActivityItem["attribution"];
-type ContinuityActivityItem = Extract<ActivityItem, { itemKind: "continuity" }>;
-type ReadActivityItem = Extract<ActivityItem, { eventKind: "read" }>;
-type StageActivityItem = Extract<ActivityItem, { eventKind: "stage" }>;
-type TransitionActivityItem = Extract<ActivityItem, { eventKind: "transition" }>;
-
-function trimId(value: string | null | undefined): string {
-  if (value === null || value === undefined || value.length === 0) {
-    return "unknown";
-  }
-  const parts = value.split(":");
-  return parts.at(-1) ?? value;
-}
-
-function shortSha(value: string | null): string {
-  return value === null ? "unknown" : value.slice(0, 7);
-}
-
-function actorLabel(attribution: AttributionSummary): string {
-  const actorId = trimId(attribution.actor.actorId);
-  const actorKind = attribution.actor.actorKind;
-  return actorKind === "unknown" ? `actor:${actorId}` : `${actorKind}:${actorId}`;
-}
-
-function summarizePaths(paths: readonly string[]): string {
-  if (paths.length === 0) {
-    return "no paths";
-  }
-  if (paths.length === 1) {
-    return paths[0] ?? "no paths";
-  }
-  if (paths.length === 2) {
-    return `${paths[0] ?? ""}, ${paths[1] ?? ""}`;
-  }
-  return `${paths[0] ?? ""}, ${paths[1] ?? ""} +${String(paths.length - 2)} more`;
-}
-
-function formatContinuityItem(item: ContinuityActivityItem): string {
-  const origin = item.continuedFromCausalSessionId === null
-    ? ""
-    : ` from session:${trimId(item.continuedFromCausalSessionId)}`;
-  return `${item.occurredAt}  continuity:${item.operation}  ${actorLabel(item.attribution)}  session:${trimId(item.causalSessionId)}  strand:${trimId(item.strandId)}${origin}`;
-}
-
-function formatReadItem(item: ReadActivityItem): string {
-  return `${item.occurredAt}  read:${item.payload.surface}/${item.payload.projection}  ${actorLabel(item.attribution)}  ${summarizePaths(item.footprint.paths)}`;
-}
-
-function formatStageItem(item: StageActivityItem): string {
-  return `${item.occurredAt}  stage:${item.payload.selectionKind}  ${actorLabel(item.attribution)}  ${summarizePaths(item.footprint.paths)}`;
-}
-
-function formatTransitionItem(item: TransitionActivityItem): string {
-  return `${item.occurredAt}  transition  ${actorLabel(item.attribution)}  ${item.payload.summary}`;
-}
-
-function formatActivityItem(item: ActivityItem): string {
-  if ("itemKind" in item) {
-    return formatContinuityItem(item);
-  }
-  if (item.eventKind === "read") {
-    return formatReadItem(item);
-  }
-  if (item.eventKind === "stage") {
-    return formatStageItem(item);
-  }
-  return formatTransitionItem(item);
-}
-
-export function renderActivityView(output: unknown): string {
-  const parsed = DIAG_ACTIVITY_CLI_SCHEMA.parse(output);
-  const lines = [
-    "Activity",
-    `repo: ${parsed.repoId ?? "unknown"}`,
-    `worktree: ${parsed.worktreeId ?? "unknown"}`,
-    `anchor: ${parsed.anchor.headRef ?? parsed.anchor.posture} @ ${shortSha(parsed.anchor.headSha)}`,
-    `truth: ${parsed.truthClass}`,
-    `next: ${parsed.nextAction}`,
-    `degraded: ${parsed.degradedReasons.length === 0 ? "none" : parsed.degradedReasons.join(", ")}`,
-    "",
-    parsed.summary.headline,
-    parsed.summary.anchor,
-    parsed.summary.workspace,
-  ];
-
-  if (parsed.activityWindow.returned === 0) {
-    lines.push("", "No activity items found in the requested window.");
-    return lines.join("\n");
-  }
-
-  lines.push("");
-  lines.push(`window: ${String(parsed.activityWindow.returned)} shown / ${String(parsed.activityWindow.totalMatchingItems)} matching${parsed.activityWindow.truncated ? " (truncated)" : ""}`);
-  lines.push("");
-  lines.push("Groups");
-
-  for (const group of parsed.activityWindow.groups) {
-    lines.push("");
-    lines.push(`${group.label} (${String(group.items.length)})`);
-    lines.push(group.summary);
-    for (const item of group.items) {
-      lines.push(`  ${formatActivityItem(item)}`);
-    }
-  }
-
-  return lines.join("\n").trimEnd();
-}