feat(shared): enhance output and progress tracing

- Added rendering enhancements for commit output.
- Introduced progress tracking features in tracing module.
- Created new config for progress rendering attributes.

These updates improve the commit output formatting and add new progress
tracking capabilities. The rendering logic for commit results is cleaned
up, and precise control over attribute visibility is implemented in the
progress module.

Co-Authored-By: Git Agent <noreply@git-agent.dev>

Author: xesrevinu

src/shared/output.ts

@@ -1,16 +1,39 @@
 import { Console, Effect } from "effect";
 import type { SingleCommitResult } from "../domain/commit";
 
+const indent = (value: string, prefix = "   "): string =>
+  value
+    .split("\n")
+    .map((line) => `${prefix}${line}`)
+    .join("\n");
+
+const renderFiles = (files: ReadonlyArray<string>): string =>
+  files.length === 0 ? "Files: none" : `Files: ${files.join(", ")}`;
+
+const renderCommitBlock = (commit: SingleCommitResult, index: number): string => {
+  const sections = [`${index + 1}. ${commit.title}`, indent(renderFiles(commit.files))];
+
+  for (const bullet of commit.bullets) {
+    sections.push(indent(`- ${bullet}`));
+  }
+
+  if (commit.explanation.trim().length > 0) {
+    sections.push(indent(commit.explanation.trim()));
+  }
+
+  if (commit.output?.trim().length) {
+    sections.push(indent(commit.output.trim()));
+  }
+
+  return sections.join("\n");
+};
+
 export const printDryRunResult = (commits: ReadonlyArray<SingleCommitResult>) =>
-  Effect.forEach(commits, (commit, index) =>
-    Console.log(`${index + 1}. ${commit.title}\n   ${commit.files.join(", ")}`),
-  );
+  Effect.forEach(commits, (commit, index) => Console.log(renderCommitBlock(commit, index)));
 
 export const printCommitResult = (commits: ReadonlyArray<SingleCommitResult>) =>
-  Effect.forEach(commits, (commit) =>
-    Console.log(
-      [commit.output?.trim(), commit.explanation.trim()]
-        .filter((value) => value != null && value.length > 0)
-        .join("\n"),
-    ),
+  Console.log(
+    [`Created ${commits.length} commit${commits.length === 1 ? "" : "s"}.`, ""]
+      .concat(commits.map((commit, index) => renderCommitBlock(commit, index)).join("\n\n"))
+      .join("\n"),
   );

src/shared/progress-config.ts

@@ -0,0 +1,144 @@
+import type { ProgressAttributeDescriptor, ProgressRenderConfig } from "./tracing";
+
+const hiddenAttributePrefixes = ["http.request.header.", "http.response.header."];
+
+const hiddenInteractiveAttributeKeys = new Set([
+  "concurrency",
+  "gen_ai.openai.request.response_format",
+  "gen_ai.openai.response.service_tier",
+  "gen_ai.operation.name",
+  "gen_ai.response.id",
+  "gen_ai.system",
+  "server.port",
+  "url.full",
+]);
+
+const orderedInteractiveAttributeKeys = [
+  "vcs",
+  "requested_vcs",
+  "dry_run",
+  "no_stage",
+  "amend",
+  "step",
+  "reason",
+  "full_wizard",
+  "hook_count",
+  "max_commits",
+  "staged_files",
+  "unstaged_files",
+  "file_count",
+  "http.request.method",
+  "url.path",
+  "http.response.status_code",
+  "server.address",
+  "gen_ai.request.model",
+  "gen_ai.response.model",
+] as const;
+
+const interactiveLabelByKey: Record<string, string> = {
+  file_count: "files",
+  hook_count: "hooks",
+  max_commits: "commits",
+  staged_files: "staged",
+  unstaged_files: "unstaged",
+  "gen_ai.request.model": "model",
+  "gen_ai.response.model": "model",
+  "http.request.method": "method",
+  "http.response.status_code": "status",
+  "server.address": "server",
+  "url.path": "path",
+};
+
+const toInteractiveDescriptors = (
+  attributes: ReadonlyMap<string, unknown>,
+): Array<ProgressAttributeDescriptor> => {
+  const descriptors: Array<ProgressAttributeDescriptor> = [];
+  const used = new Set<string>();
+
+  const push = (
+    key: string,
+    value: unknown,
+    label = interactiveLabelByKey[key] ?? key,
+    dedupeKey?: string,
+  ) => {
+    if (value === undefined || value === null) {
+      return;
+    }
+    used.add(key);
+    descriptors.push(
+      dedupeKey == null
+        ? {
+            key,
+            label,
+            value,
+          }
+        : {
+            key,
+            label,
+            value,
+            dedupeKey,
+          },
+    );
+  };
+
+  const groupIndex = attributes.get("group_index");
+  const groupTotal = attributes.get("group_total");
+  if (groupIndex !== undefined && groupTotal !== undefined) {
+    used.add("group_index");
+    used.add("group_total");
+    descriptors.push({
+      key: "group_index",
+      label: "group",
+      value: `${groupIndex}/${groupTotal}`,
+      dedupeKey: `group=${groupIndex}/${groupTotal}`,
+    });
+  }
+
+  const inputTokens = attributes.get("gen_ai.usage.input_tokens");
+  const outputTokens = attributes.get("gen_ai.usage.output_tokens");
+  if (inputTokens !== undefined || outputTokens !== undefined) {
+    used.add("gen_ai.usage.input_tokens");
+    used.add("gen_ai.usage.output_tokens");
+    descriptors.push({
+      key: "gen_ai.usage.input_tokens",
+      label: "tokens",
+      value: `${inputTokens ?? 0}/${outputTokens ?? 0}`,
+      dedupeKey: `tokens=${inputTokens ?? 0}/${outputTokens ?? 0}`,
+    });
+  }
+
+  for (const key of orderedInteractiveAttributeKeys) {
+    if (used.has(key) || !attributes.has(key)) {
+      continue;
+    }
+    push(key, attributes.get(key));
+  }
+
+  const remaining = [...attributes.entries()]
+    .filter(([key, value]) => {
+      if (used.has(key) || value === undefined || value === null) {
+        return false;
+      }
+      if (hiddenInteractiveAttributeKeys.has(key)) {
+        return false;
+      }
+      return hiddenAttributePrefixes.every((prefix) => !key.startsWith(prefix));
+    })
+    .sort(([left], [right]) => left.localeCompare(right));
+
+  for (const [key, value] of remaining) {
+    push(key, value);
+  }
+
+  return descriptors;
+};
+
+export const gitAgentProgressRenderConfig: ProgressRenderConfig = {
+  headerLabel: "Git agent",
+  formatAttributes({ attributes }, { mode }) {
+    if (mode === "raw") {
+      return undefined;
+    }
+    return toInteractiveDescriptors(attributes);
+  },
+};