supipowers 1.5.2 → 2.0.0

package/src/workspace/selector.ts

@@ -0,0 +1,115 @@
+import type { WorkspaceTarget } from "../types.js";
+
+export interface WorkspaceTargetOption<TTarget extends WorkspaceTarget = WorkspaceTarget> {
+  target: TTarget;
+  changed: boolean;
+  label?: string;
+}
+
+export function tokenizeCliArgs(args?: string): string[] {
+  if (!args) {
+    return [];
+  }
+
+  return (args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) ?? [])
+    .map((token) => token.replace(/^['"]|['"]$/g, ""));
+}
+
+export function stripCliArg(args: string | undefined, flag: string): string | undefined {
+  const tokens = tokenizeCliArgs(args);
+  const retained: string[] = [];
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token === flag) {
+      index += 1;
+      continue;
+    }
+    if (token.startsWith(`${flag}=`)) {
+      continue;
+    }
+    retained.push(token);
+  }
+
+  return retained.length > 0 ? retained.join(" ") : undefined;
+}
+
+export function parseTargetArg(args?: string): string | null {
+  const tokens = tokenizeCliArgs(args);
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token === "--target") {
+      return tokens[index + 1] ?? null;
+    }
+    if (token.startsWith("--target=")) {
+      return token.slice("--target=".length) || null;
+    }
+  }
+
+  return null;
+}
+
+export function resolveRequestedWorkspaceTarget<TTarget extends WorkspaceTarget>(
+  targets: TTarget[],
+  requestedTarget: string | null,
+): TTarget | null {
+  if (!requestedTarget) {
+    return null;
+  }
+
+  return targets.find((target) => target.id === requestedTarget || target.name === requestedTarget) ?? null;
+}
+
+export function sortWorkspaceTargetOptions<TTarget extends WorkspaceTarget>(
+  options: WorkspaceTargetOption<TTarget>[],
+): WorkspaceTargetOption<TTarget>[] {
+  return [...options].sort((left, right) => {
+    if (left.changed !== right.changed) {
+      return left.changed ? -1 : 1;
+    }
+    return left.target.name.localeCompare(right.target.name);
+  });
+}
+
+export function buildWorkspaceTargetOptionLabel(
+  option: WorkspaceTargetOption,
+  details: string[] = [],
+): string {
+  return [
+    option.target.name,
+    option.target.relativeDir,
+    ...details.map((detail) => detail.trim()).filter(Boolean),
+  ].join(" — ");
+}
+
+export async function selectWorkspaceTarget<TTarget extends WorkspaceTarget>(
+  ctx: { ui: { select(title: string, options: string[], opts?: any): Promise<string | null> } },
+  options: WorkspaceTargetOption<TTarget>[],
+  requestedTarget: string | null,
+  selection: {
+    title: string;
+    helpText?: string;
+    autoSelectSingle?: boolean;
+  },
+): Promise<TTarget | null> {
+  if (requestedTarget) {
+    return resolveRequestedWorkspaceTarget(options.map((option) => option.target), requestedTarget);
+  }
+
+  const autoSelectSingle = selection.autoSelectSingle ?? true;
+  if (autoSelectSingle && options.length === 1) {
+    return options[0]?.target ?? null;
+  }
+
+  const labels = options.map((option) => option.label ?? buildWorkspaceTargetOptionLabel(option));
+  const choice = await ctx.ui.select(selection.title, labels, {
+    helpText: selection.helpText,
+  });
+  if (!choice) {
+    return null;
+  }
+
+  const selectedIndex = labels.indexOf(choice);
+  return selectedIndex >= 0 ? options[selectedIndex]?.target ?? null : null;
+}

package/src/workspace/state-paths.ts

@@ -0,0 +1,118 @@
+import path from "node:path";
+import type { PlatformPaths } from "../platform/types.js";
+import type { WorkspaceTarget } from "../types.js";
+import { projectSlugFromRepoRoot } from "./project-slug.js";
+import { resolveRepoIdentityRootFromFs } from "./repo-root.js";
+import { ROOT_WORKSPACE_RELATIVE_DIR, normalizeWorkspaceRelativePath } from "./targets.js";
+
+const WORKSPACES_DIR = "workspaces";
+const PROJECTS_DIR = "projects";
+
+function splitWorkspacePath(relativeDir: string): string[] {
+  const normalized = normalizeWorkspaceRelativePath(relativeDir);
+  return normalized === ROOT_WORKSPACE_RELATIVE_DIR ? [] : normalized.split("/").filter(Boolean);
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Team-shared (local) state: <cwd-or-repoRoot>/.omp/supipowers/<...>
+//
+// These paths are committed (or at least shareable) across a team clone. Used for
+// config.json, model.json, review-agents/config.yml, mcpc manifests, etc.
+// ──────────────────────────────────────────────────────────────────────────
+
+export function getRootStateDir(paths: PlatformPaths, repoRoot: string): string {
+  return paths.project(repoRoot);
+}
+
+export function getWorkspaceStateDir(
+  paths: PlatformPaths,
+  repoRoot: string,
+  workspaceRelativeDir: string,
+): string {
+  return path.join(getRootStateDir(paths, repoRoot), WORKSPACES_DIR, ...splitWorkspacePath(workspaceRelativeDir));
+}
+
+export function getTargetStateDir(paths: PlatformPaths, target: WorkspaceTarget): string {
+  return target.kind === "root"
+    ? getRootStateDir(paths, target.repoRoot)
+    : getWorkspaceStateDir(paths, target.repoRoot, target.relativeDir);
+}
+
+export function getRootConfigPath(paths: PlatformPaths, repoRoot: string): string {
+  return path.join(getRootStateDir(paths, repoRoot), "config.json");
+}
+
+/**
+ * Resolve a team-shared config/data path inside `<cwd>/.omp/supipowers/...`.
+ * Use this for files that belong to the repo: project config, model config, review-agent
+ * definitions. Do not use this for per-invocation execution state — that goes through
+ * {@link getProjectStatePath}.
+ */
+export function getLocalStatePath(paths: PlatformPaths, cwd: string, ...segments: string[]): string {
+  return paths.project(cwd, ...segments);
+}
+
+/**
+ * Workspace-aware variant of {@link getLocalStatePath}. Root targets resolve under the repo
+ * root; workspace targets resolve under `<repo>/.omp/supipowers/workspaces/<rel>/...`.
+ */
+export function getLocalTargetStatePath(
+  paths: PlatformPaths,
+  target: WorkspaceTarget,
+  ...segments: string[]
+): string {
+  return path.join(getTargetStateDir(paths, target), ...segments);
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Project-scoped (global) execution state: ~/.omp/supipowers/projects/<slug>/<...>
+//
+// These paths are keyed by a deterministic slug derived from the repo identity root, so
+// multiple clones of the same repo do not collide. Used for plans, reviews, reports,
+// debug traces, telemetry, visual/ui-design sessions, etc.
+// ──────────────────────────────────────────────────────────────────────────
+
+/**
+ * Resolve the project-scoped global state directory for the repo containing `cwd`.
+ */
+export function getProjectStateDir(paths: PlatformPaths, cwd: string): string {
+  const identityRoot = resolveRepoIdentityRootFromFs(cwd);
+  const slug = projectSlugFromRepoRoot(identityRoot);
+  return paths.global(PROJECTS_DIR, slug);
+}
+
+/**
+ * Resolve a path inside the project-scoped global state directory for `cwd`.
+ * Use this for per-invocation execution artifacts (plans, reviews, reports, debug logs, etc.).
+ */
+export function getProjectStatePath(
+  paths: PlatformPaths,
+  cwd: string,
+  ...segments: string[]
+): string {
+  return path.join(getProjectStateDir(paths, cwd), ...segments);
+}
+
+/**
+ * Resolve the project-scoped global state directory for a specific workspace target.
+ * Root targets resolve under `<slug>/`; workspace targets resolve under
+ * `<slug>/workspaces/<rel>/`.
+ */
+export function getProjectTargetStateDir(paths: PlatformPaths, target: WorkspaceTarget): string {
+  const base = getProjectStateDir(paths, target.repoRoot);
+  if (target.kind === "root") {
+    return base;
+  }
+  return path.join(base, WORKSPACES_DIR, ...splitWorkspacePath(target.relativeDir));
+}
+
+/**
+ * Workspace-aware variant of {@link getProjectStatePath}.
+ */
+export function getProjectTargetStatePath(
+  paths: PlatformPaths,
+  target: WorkspaceTarget,
+  ...segments: string[]
+): string {
+  return path.join(getProjectTargetStateDir(paths, target), ...segments);
+}

package/src/workspace/targets.ts

@@ -0,0 +1,313 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+import type { PackageManagerId, WorkspaceTarget, WorkspaceTargetKind } from "../types.js";
+
+interface WorkspaceManifest {
+  name?: string;
+  version?: string;
+  private?: boolean;
+  workspaces?: unknown;
+}
+
+interface WorkspaceObjectConfig {
+  packages?: unknown;
+}
+
+interface PnpmWorkspaceConfig {
+  packages?: unknown;
+}
+
+const IGNORED_WORKSPACE_DIRS = new Set([".git", "node_modules"]);
+export const ROOT_WORKSPACE_RELATIVE_DIR = ".";
+
+export function normalizeWorkspaceRelativePath(value: string): string {
+  const normalized = value
+    .replace(/\\/g, "/")
+    .replace(/^\.\//, "")
+    .replace(/^\//, "")
+    .replace(/\/package\.json$/, "")
+    .replace(/\/+$/, "");
+
+  return normalized.length > 0 ? normalized : ROOT_WORKSPACE_RELATIVE_DIR;
+}
+
+export function toWorkspaceRelativeDir(repoRoot: string, dir: string): string {
+  return normalizeWorkspaceRelativePath(path.relative(repoRoot, dir));
+}
+
+function readManifest(manifestPath: string): WorkspaceManifest | null {
+  try {
+    return JSON.parse(fs.readFileSync(manifestPath, "utf-8")) as WorkspaceManifest;
+  } catch {
+    return null;
+  }
+}
+
+function isWorkspacePackagesConfig(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+
+function readPackageJsonWorkspacePatterns(manifest: WorkspaceManifest): string[] {
+  if (isWorkspacePackagesConfig(manifest.workspaces)) {
+    return manifest.workspaces;
+  }
+
+  if (manifest.workspaces && typeof manifest.workspaces === "object" && !Array.isArray(manifest.workspaces)) {
+    const packages = (manifest.workspaces as WorkspaceObjectConfig).packages;
+    if (isWorkspacePackagesConfig(packages)) {
+      return packages;
+    }
+  }
+
+  return [];
+}
+
+function readPnpmWorkspacePatterns(repoRoot: string): string[] {
+  const workspacePath = path.join(repoRoot, "pnpm-workspace.yaml");
+  if (!fs.existsSync(workspacePath)) {
+    return [];
+  }
+
+  try {
+    const parsed = parseYaml(fs.readFileSync(workspacePath, "utf-8")) as PnpmWorkspaceConfig | null;
+    return isWorkspacePackagesConfig(parsed?.packages) ? parsed.packages : [];
+  } catch {
+    return [];
+  }
+}
+
+function expandBracePatterns(pattern: string): string[] {
+  const start = pattern.indexOf("{");
+  if (start === -1) {
+    return [pattern];
+  }
+
+  const end = pattern.indexOf("}", start + 1);
+  if (end === -1) {
+    return [pattern];
+  }
+
+  const prefix = pattern.slice(0, start);
+  const suffix = pattern.slice(end + 1);
+  return pattern
+    .slice(start + 1, end)
+    .split(",")
+    .flatMap((option) => expandBracePatterns(`${prefix}${option}${suffix}`));
+}
+
+function normalizeWorkspacePattern(pattern: string): string {
+  return normalizeWorkspaceRelativePath(pattern);
+}
+
+function listDirectories(dir: string): string[] {
+  try {
+    return fs
+      .readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && !IGNORED_WORKSPACE_DIRS.has(entry.name))
+      .map((entry) => entry.name)
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+function hasMagic(segment: string): boolean {
+  return segment.includes("*") || segment.includes("?");
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function matchesSegment(name: string, pattern: string): boolean {
+  const regex = new RegExp(
+    `^${escapeRegExp(pattern)
+      .replace(/\\\*/g, "[^/]*")
+      .replace(/\\\?/g, "[^/]")}$`,
+  );
+  return regex.test(name);
+}
+
+function expandWorkspacePattern(repoRoot: string, pattern: string): string[] {
+  const normalizedPattern = normalizeWorkspacePattern(pattern);
+  if (normalizedPattern === ROOT_WORKSPACE_RELATIVE_DIR) {
+    return fs.existsSync(path.join(repoRoot, "package.json")) ? [repoRoot] : [];
+  }
+
+  const segments = normalizedPattern.split("/").filter(Boolean);
+  const matches = new Set<string>();
+
+  const visit = (currentDir: string, index: number): void => {
+    if (index >= segments.length) {
+      if (fs.existsSync(path.join(currentDir, "package.json"))) {
+        matches.add(currentDir);
+      }
+      return;
+    }
+
+    const segment = segments[index];
+    if (segment === "**") {
+      visit(currentDir, index + 1);
+      for (const child of listDirectories(currentDir)) {
+        visit(path.join(currentDir, child), index);
+      }
+      return;
+    }
+
+    if (!hasMagic(segment)) {
+      const nextDir = path.join(currentDir, segment);
+      if (fs.existsSync(nextDir) && fs.statSync(nextDir).isDirectory()) {
+        visit(nextDir, index + 1);
+      }
+      return;
+    }
+
+    for (const child of listDirectories(currentDir)) {
+      if (matchesSegment(child, segment)) {
+        visit(path.join(currentDir, child), index + 1);
+      }
+    }
+  };
+
+  visit(repoRoot, 0);
+  return [...matches].sort();
+}
+
+function globPathToRegExp(pattern: string): RegExp {
+  const normalizedPattern = normalizeWorkspacePattern(pattern);
+  if (normalizedPattern === ROOT_WORKSPACE_RELATIVE_DIR) {
+    return /^\.$/;
+  }
+
+  let regex = "^";
+  for (let index = 0; index < normalizedPattern.length; index += 1) {
+    const char = normalizedPattern[index];
+    const nextChar = normalizedPattern[index + 1];
+    if (char === "*" && nextChar === "*") {
+      regex += ".*";
+      index += 1;
+      continue;
+    }
+    if (char === "*") {
+      regex += "[^/]*";
+      continue;
+    }
+    if (char === "?") {
+      regex += "[^/]";
+      continue;
+    }
+    regex += escapeRegExp(char);
+  }
+
+  regex += "$";
+  return new RegExp(regex);
+}
+
+function collectWorkspaceDirectories(repoRoot: string, patterns: string[]): string[] {
+  const expandedPatterns = patterns.flatMap((pattern) => expandBracePatterns(pattern));
+  const includePatterns = expandedPatterns.filter((pattern) => !pattern.startsWith("!"));
+  const excludeMatchers = expandedPatterns
+    .filter((pattern) => pattern.startsWith("!"))
+    .map((pattern) => globPathToRegExp(pattern.slice(1)));
+
+  const directories = new Set<string>();
+  for (const pattern of includePatterns) {
+    for (const dir of expandWorkspacePattern(repoRoot, pattern)) {
+      const relativeDir = toWorkspaceRelativeDir(repoRoot, dir);
+      if (excludeMatchers.some((matcher) => matcher.test(relativeDir))) {
+        continue;
+      }
+      directories.add(dir);
+    }
+  }
+
+  return [...directories].sort((left, right) => {
+    const leftRelative = toWorkspaceRelativeDir(repoRoot, left);
+    const rightRelative = toWorkspaceRelativeDir(repoRoot, right);
+    return leftRelative.localeCompare(rightRelative);
+  });
+}
+
+function isWorkspaceTargetManifest(manifest: WorkspaceManifest | null): manifest is WorkspaceManifest & { name: string; version?: string } {
+  return typeof manifest?.name === "string" && manifest.name.trim().length > 0;
+}
+
+function buildWorkspaceTarget(
+  repoRoot: string,
+  packageDir: string,
+  manifest: WorkspaceManifest & { name: string; version?: string },
+  packageManager: PackageManagerId,
+  kind: WorkspaceTargetKind,
+): WorkspaceTarget {
+  return {
+    id: manifest.name,
+    name: manifest.name,
+    kind,
+    repoRoot,
+    packageDir,
+    manifestPath: path.join(packageDir, "package.json"),
+    relativeDir: toWorkspaceRelativeDir(repoRoot, packageDir),
+    version: typeof manifest.version === "string" && manifest.version.trim().length > 0
+      ? manifest.version
+      : "0.0.0",
+    private: manifest.private === true,
+    packageManager,
+  };
+}
+
+export function discoverWorkspaceTargets(repoRoot: string, packageManager: PackageManagerId): WorkspaceTarget[] {
+  const rootManifestPath = path.join(repoRoot, "package.json");
+  const rootManifest = readManifest(rootManifestPath);
+  const targetByManifestPath = new Map<string, WorkspaceTarget>();
+
+  if (isWorkspaceTargetManifest(rootManifest)) {
+    targetByManifestPath.set(
+      rootManifestPath,
+      buildWorkspaceTarget(repoRoot, repoRoot, rootManifest, packageManager, "root"),
+    );
+  }
+
+  const workspacePatterns = [
+    ...readPackageJsonWorkspacePatterns(rootManifest ?? {}),
+    ...readPnpmWorkspacePatterns(repoRoot),
+  ];
+
+  for (const workspaceDir of collectWorkspaceDirectories(repoRoot, workspacePatterns)) {
+    const manifestPath = path.join(workspaceDir, "package.json");
+    const manifest = readManifest(manifestPath);
+    if (!isWorkspaceTargetManifest(manifest)) {
+      continue;
+    }
+
+    targetByManifestPath.set(
+      manifestPath,
+      buildWorkspaceTarget(
+        repoRoot,
+        workspaceDir,
+        manifest,
+        packageManager,
+        workspaceDir === repoRoot ? "root" : "workspace",
+      ),
+    );
+  }
+
+  // Synthesize a root target when the repo is a monorepo (workspacePatterns exist) but the
+  // root package.json has no name field (pure workspace aggregators often omit it). Without
+  // a root target, root-level files like bun.lock, .gitignore, and config files have no
+  // mapping and become unaddressable by workspace-aware commands.
+  if (!targetByManifestPath.has(rootManifestPath) && workspacePatterns.length > 0) {
+    const fallbackName = path.basename(repoRoot) || "root";
+    targetByManifestPath.set(
+      rootManifestPath,
+      buildWorkspaceTarget(repoRoot, repoRoot, { name: fallbackName }, packageManager, "root"),
+    );
+  }
+
+  return [...targetByManifestPath.values()].sort((left, right) => {
+    if (left.kind !== right.kind) {
+      return left.kind === "root" ? -1 : 1;
+    }
+    return left.relativeDir.localeCompare(right.relativeDir);
+  });
+}

package/src/fix-pr/scripts/diff-comments.sh

@@ -1,33 +0,0 @@
-#!/bin/bash
-# Compares two JSONL comment snapshots, outputs only new/changed comments
-# Usage: diff-comments.sh <prev_snapshot> <new_snapshot>
-# Exit 0 if new comments found, exit 1 if identical
-set -euo pipefail
-
-PREV="$1"
-NEW="$2"
-
-# If no previous snapshot, all comments are new
-if [[ ! -f "$PREV" ]]; then
-  cat "$NEW"
-  exit 0
-fi
-
-# Build fingerprint: id + updatedAt for each comment
-prev_fingerprints=$(jq -r '[.id, .updatedAt] | @tsv' "$PREV" 2>/dev/null | sort)
-new_fingerprints=$(jq -r '[.id, .updatedAt] | @tsv' "$NEW" 2>/dev/null | sort)
-
-# Find IDs that are new or changed
-new_ids=$(comm -13 <(echo "$prev_fingerprints") <(echo "$new_fingerprints") | cut -f1)
-
-if [[ -z "$new_ids" ]]; then
-  exit 1
-fi
-
-# Output the full comment objects for new/changed IDs
-while IFS= read -r id; do
-  [[ -z "$id" ]] && continue
-  jq -c "select(.id == $id)" "$NEW"
-done <<< "$new_ids"
-
-exit 0

package/src/fix-pr/scripts/fetch-pr-comments.sh

@@ -1,25 +0,0 @@
-#!/bin/bash
-# Fetches all review comments for a PR, outputs JSONL
-# Usage: fetch-pr-comments.sh <owner/repo> <pr_number> <output_file>
-set -euo pipefail
-
-REPO="$1"
-PR="$2"
-OUTPUT="$3"
-
-# Ensure output directory exists
-mkdir -p "$(dirname "$OUTPUT")"
-
-# Fetch inline review comments (code-level)
-gh api --paginate "repos/${REPO}/pulls/${PR}/comments" \
-  --jq '.[] | {id, path, line: .line, body, user: .user.login, userType: .user.type, createdAt: .created_at, updatedAt: .updated_at, inReplyToId: .in_reply_to_id, diffHunk: .diff_hunk, state: "COMMENTED"}' \
-  > "$OUTPUT" 2>/dev/null || true
-
-# Fetch review-level comments (top-level reviews with body text)
-gh api --paginate "repos/${REPO}/pulls/${PR}/reviews" \
-  --jq '.[] | select(.body != null and .body != "") | {id, path: null, line: null, body, user: .user.login, userType: .user.type, createdAt: .submitted_at, updatedAt: .submitted_at, inReplyToId: null, diffHunk: null, state}' \
-  >> "$OUTPUT" 2>/dev/null || true
-
-# Output summary to stderr for caller
-TOTAL=$(wc -l < "$OUTPUT" | tr -d ' ')
-echo "{\"total\": ${TOTAL}}" >&2

package/src/fix-pr/scripts/trigger-review.sh

@@ -1,36 +0,0 @@
-#!/bin/bash
-# Triggers automated reviewer to re-review a PR
-# Usage: trigger-review.sh <owner/repo> <pr_number> <reviewer_type> <trigger_method>
-set -euo pipefail
-
-REPO="$1"
-PR="$2"
-REVIEWER="$3"
-METHOD="${4:-}"
-
-case "$REVIEWER" in
-  coderabbit)
-    gh api "repos/${REPO}/issues/${PR}/comments" -f body="$METHOD" >/dev/null 2>&1
-    echo '{"triggered": true, "reviewer": "coderabbit"}'
-    ;;
-  copilot)
-    if [[ -n "$METHOD" ]]; then
-      gh api "repos/${REPO}/issues/${PR}/comments" -f body="$METHOD" >/dev/null 2>&1
-    else
-      gh api "repos/${REPO}/pulls/${PR}/requested_reviewers" \
-        --method POST -f "reviewers[]=copilot" >/dev/null 2>&1 || true
-    fi
-    echo '{"triggered": true, "reviewer": "copilot"}'
-    ;;
-  gemini)
-    gh api "repos/${REPO}/issues/${PR}/comments" -f body="$METHOD" >/dev/null 2>&1
-    echo '{"triggered": true, "reviewer": "gemini"}'
-    ;;
-  none)
-    echo '{"triggered": false, "reviewer": "none"}'
-    ;;
-  *)
-    echo '{"triggered": false, "error": "unknown reviewer type: '"$REVIEWER"'"}'
-    exit 1
-    ;;
-esac

package/src/fix-pr/scripts/wait-and-check.sh

@@ -1,37 +0,0 @@
-#!/bin/bash
-# Waits for delay, fetches new PR comments, diffs against previous snapshot
-# Usage: wait-and-check.sh <session_dir> <delay_seconds> <iteration> <owner/repo> <pr_number>
-# Output: new comment lines + JSON summary on last line
-set -euo pipefail
-
-SESSION_DIR="$1"
-DELAY="$2"
-ITERATION="$3"
-REPO="$4"
-PR="$5"
-
-SNAPSHOTS_DIR="${SESSION_DIR}/snapshots"
-PREV_ITERATION=$((ITERATION - 1))
-PREV_SNAPSHOT="${SNAPSHOTS_DIR}/comments-${PREV_ITERATION}.jsonl"
-NEW_SNAPSHOT="${SNAPSHOTS_DIR}/comments-${ITERATION}.jsonl"
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-
-# Wait for reviewer to process
-echo "Waiting ${DELAY}s for reviewer to process changes..." >&2
-sleep "$DELAY"
-
-# Fetch new comments
-echo "Fetching PR comments (iteration ${ITERATION})..." >&2
-bash "${SCRIPT_DIR}/fetch-pr-comments.sh" "$REPO" "$PR" "$NEW_SNAPSHOT"
-
-# Diff against previous
-DIFF_OUTPUT=$(bash "${SCRIPT_DIR}/diff-comments.sh" "$PREV_SNAPSHOT" "$NEW_SNAPSHOT" 2>/dev/null) || true
-
-if [[ -n "$DIFF_OUTPUT" ]]; then
-  DIFF_COUNT=$(echo "$DIFF_OUTPUT" | wc -l | tr -d ' ')
-  echo "$DIFF_OUTPUT"
-  echo "{\"hasNewComments\": true, \"count\": ${DIFF_COUNT}, \"iteration\": ${ITERATION}}"
-else
-  echo "{\"hasNewComments\": false, \"count\": 0, \"iteration\": ${ITERATION}}"
-fi