supipowers 2.2.0 → 2.2.2

package/src/config/schema.ts

@@ -1,176 +1,142 @@
-import type { TSchema } from "@sinclair/typebox";
-import { Type } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
+import { z } from "zod/v4";
+import type { ZodType } from "zod/v4";
 import type { SupipowersConfig } from "../types.js";
 import { QualityGatesSchema } from "../quality/schemas.js";
 import { UltraPlanConfigSchema } from "../ultraplan/contracts.js";
+import { collectSchemaValidationErrors } from "../ai/schema-validation.js";
 
 const TAG_FORMAT_PATTERN = "^(?:(?!\\$\\{version\\}).)*\\$\\{version\\}(?:(?!\\$\\{version\\}).)*$";
 
 
-export const ConfigSchema = Type.Object(
+export const ConfigSchema = z.object(
   {
-    version: Type.String(),
-    quality: Type.Object(
+    version: z.string(),
+    quality: z.object(
       {
         gates: QualityGatesSchema,
       },
-      { additionalProperties: false },
-    ),
-    lsp: Type.Object(
+    ).strict(),
+    lsp: z.object(
       {
-        setupGuide: Type.Boolean(),
+        setupGuide: z.boolean(),
       },
-      { additionalProperties: false },
-    ),
-    qa: Type.Object(
+    ).strict(),
+    qa: z.object(
       {
-        framework: Type.Union([Type.String(), Type.Null()]),
-        e2e: Type.Boolean(),
+        framework: z.string().nullable(),
+        e2e: z.boolean(),
       },
-      { additionalProperties: false },
-    ),
-    release: Type.Object(
+    ).strict(),
+    release: z.object(
       {
-        channels: Type.Array(Type.String()),
-        tagFormat: Type.String({ pattern: TAG_FORMAT_PATTERN }),
-        customChannels: Type.Optional(
-          Type.Record(
-            Type.String(),
-            Type.Object({
-              label: Type.String(),
-              publishCommand: Type.String(),
-              detectCommand: Type.Optional(Type.String()),
-            }),
-          ),
-        ),
+        channels: z.array(z.string()),
+        tagFormat: z.string().regex(new RegExp(TAG_FORMAT_PATTERN)),
+        customChannels: z.record(
+          z.string(),
+          z.object({
+            label: z.string(),
+            publishCommand: z.string(),
+            detectCommand: z.string().optional(),
+          }),
+        ).optional(),
       },
-      { additionalProperties: false },
-    ),
+    ).strict(),
     ultraplan: UltraPlanConfigSchema,
-    contextMode: Type.Object(
+    contextMode: z.object(
       {
-        enabled: Type.Boolean(),
-        compressionThreshold: Type.Number({ minimum: 1024 }),
-        blockHttpCommands: Type.Boolean(),
-        routingInstructions: Type.Boolean(),
-        eventTracking: Type.Boolean(),
-        compaction: Type.Boolean(),
-        llmSummarization: Type.Boolean(),
-        llmThreshold: Type.Number({ minimum: 4096 }),
-        enforceRouting: Type.Boolean(),
-        lazyTools: Type.Object(
+        enabled: z.boolean(),
+        compressionThreshold: z.number().min(1024),
+        blockHttpCommands: z.boolean(),
+        routingInstructions: z.boolean(),
+        eventTracking: z.boolean(),
+        compaction: z.boolean(),
+        llmSummarization: z.boolean(),
+        llmThreshold: z.number().min(4096),
+        enforceRouting: z.boolean(),
+        lazyTools: z.object(
           {
-            enabled: Type.Boolean(),
-            mode: Type.Union([
-              Type.Literal("conservative"),
-              Type.Literal("balanced"),
-              Type.Literal("aggressive"),
-            ]),
-            alwaysKeep: Type.Array(Type.String()),
-            commandAllowlist: Type.Record(Type.String(), Type.Array(Type.String())),
-            keywordTools: Type.Record(Type.String(), Type.Array(Type.String())),
+            enabled: z.boolean(),
+            mode: z.enum(["conservative", "balanced", "aggressive"]),
+            alwaysKeep: z.array(z.string()),
+            commandAllowlist: z.record(z.string(), z.array(z.string())),
+            keywordTools: z.record(z.string(), z.array(z.string())),
           },
-          { additionalProperties: false },
-        ),
-        processors: Type.Object(
+        ).strict(),
+        processors: z.object(
           {
-            enabled: Type.Boolean(),
-            disable: Type.Array(
-              Type.Union([
-                Type.Literal("git"),
-                Type.Literal("test"),
-                Type.Literal("lint"),
-                Type.Literal("build"),
-                Type.Literal("k8s"),
-                Type.Literal("docker"),
-                Type.Literal("log"),
-                Type.Literal("json"),
-              ]),
+            enabled: z.boolean(),
+            disable: z.array(
+              z.enum(["git", "test", "lint", "build", "k8s", "docker", "log", "json"]),
             ),
           },
-          { additionalProperties: false },
-        ),
-        cacheHandles: Type.Object(
+        ).strict(),
+        cacheHandles: z.object(
           {
-            enabled: Type.Boolean(),
-            spillThresholdBytes: Type.Number({ minimum: 1024 }),
-            previewBytes: Type.Number({ minimum: 256 }),
+            enabled: z.boolean(),
+            spillThresholdBytes: z.number().min(1024),
+            previewBytes: z.number().min(256),
           },
-          { additionalProperties: false },
-        ),
-        repomap: Type.Object(
+        ).strict(),
+        repomap: z.object(
           {
-            enabled: Type.Boolean(),
-            tokenBudget: Type.Number({ minimum: 100 }),
-            maxFiles: Type.Number({ minimum: 1 }),
+            enabled: z.boolean(),
+            tokenBudget: z.number().min(100),
+            maxFiles: z.number().min(1),
           },
-          { additionalProperties: false },
-        ),
-        memory: Type.Object(
+        ).strict(),
+        memory: z.object(
           {
-            enabled: Type.Boolean(),
-            byteBudget: Type.Number({ minimum: 256 }),
-            maxRows: Type.Number({ minimum: 1 }),
-            retentionDays: Type.Number({ minimum: 1 }),
-            focusChainCadence: Type.Integer({ minimum: 1 }),
+            enabled: z.boolean(),
+            byteBudget: z.number().min(256),
+            maxRows: z.number().min(1),
+            retentionDays: z.number().min(1),
+            focusChainCadence: z.number().int().min(1),
           },
-          { additionalProperties: false },
-        ),
+        ).strict(),
       },
-      { additionalProperties: false },
-    ),
-    mempalace: Type.Object(
+    ).strict(),
+    mempalace: z.object(
       {
-        enabled: Type.Boolean(),
-        packageVersion: Type.String({ minLength: 1 }),
-        managedVenvPath: Type.String({ minLength: 1 }),
-        palacePath: Type.String({ minLength: 1 }),
-        defaultWingStrategy: Type.Union([
-          Type.Literal("repo-name"),
-          Type.Literal("project-slug"),
-          Type.Literal("explicit"),
-        ]),
-        explicitWing: Type.Union([Type.String(), Type.Null()]),
-        defaultAgentName: Type.String({ minLength: 1 }),
-        autoSetup: Type.Boolean(),
-        hooks: Type.Object(
+        enabled: z.boolean(),
+        packageVersion: z.string().min(1),
+        managedVenvPath: z.string().min(1),
+        palacePath: z.string().min(1),
+        defaultWingStrategy: z.enum(["repo-name", "project-slug", "explicit"]),
+        explicitWing: z.string().nullable(),
+        defaultAgentName: z.string().min(1),
+        autoSetup: z.boolean(),
+        hooks: z.object(
           {
-            wakeUp: Type.Boolean(),
-            searchGuidance: Type.Boolean(),
-            autoSearchOnPrompt: Type.Boolean(),
-            compactionCheckpoint: Type.Boolean(),
-            shutdownDiary: Type.Boolean(),
+            wakeUp: z.boolean(),
+            searchGuidance: z.boolean(),
+            autoSearchOnPrompt: z.boolean(),
+            compactionCheckpoint: z.boolean(),
+            shutdownDiary: z.boolean(),
           },
-          { additionalProperties: false },
-        ),
-        budgets: Type.Object(
+        ).strict(),
+        budgets: z.object(
           {
-            wakeUpTokens: Type.Integer({ minimum: 1 }),
-            searchResultChars: Type.Integer({ minimum: 1 }),
-            listResultChars: Type.Integer({ minimum: 1 }),
-            diaryChars: Type.Integer({ minimum: 1 }),
-            autoSearchTokens: Type.Integer({ minimum: 1 }),
-            wakeUpInjectionEvery: Type.Integer({ minimum: 1 }),
-            autoSearchSimilarityFloor: Type.Number({ minimum: 0, maximum: 1 }),
-            autoSearchBm25Floor: Type.Number({ minimum: 0 }),
+            wakeUpTokens: z.number().int().min(1),
+            searchResultChars: z.number().int().min(1),
+            listResultChars: z.number().int().min(1),
+            diaryChars: z.number().int().min(1),
+            autoSearchTokens: z.number().int().min(1),
+            wakeUpInjectionEvery: z.number().int().min(1),
+            autoSearchSimilarityFloor: z.number().min(0).max(1),
+            autoSearchBm25Floor: z.number().min(0),
           },
-          { additionalProperties: false },
-        ),
-        timeouts: Type.Object(
+        ).strict(),
+        timeouts: z.object(
           {
-            setupMs: Type.Integer({ minimum: 1 }),
-            bridgeMs: Type.Integer({ minimum: 1 }),
-            hookMs: Type.Integer({ minimum: 1 }),
+            setupMs: z.number().int().min(1),
+            bridgeMs: z.number().int().min(1),
+            hookMs: z.number().int().min(1),
           },
-          { additionalProperties: false },
-        ),
+        ).strict(),
       },
-      { additionalProperties: false },
-    ), 
+    ).strict(),
   },
-  { additionalProperties: false },
-);
+).strict();
 
 export interface ConfigParseError {
   source: "global" | "root";
@@ -190,13 +156,10 @@ export interface InspectionLoadResult {
   validationErrors: ConfigValidationError[];
 }
 
-function normalizeErrorPath(path: string): string {
-  return path.replace(/^\//, "").replace(/\//g, ".") || "(root)";
-}
 
-function collectValidationErrors(schema: TSchema, data: unknown): ConfigValidationError[] {
-  return [...Value.Errors(schema, data)].map((error) => ({
-    path: normalizeErrorPath(error.path),
+function collectValidationErrors(schema: ZodType, data: unknown): ConfigValidationError[] {
+  return collectSchemaValidationErrors(schema, data).map((error) => ({
+    path: error.path,
     message: error.message,
   }));
 }

package/src/docs/contracts.ts

@@ -5,7 +5,7 @@
 // retry loop (runWithOutputValidation) will hand validation errors back to
 // the model rather than letting a silent regex heuristic invent findings.
 
-import { Type, type Static } from "@sinclair/typebox";
+import { z } from "zod/v4"
 
 export const DOC_DRIFT_SEVERITIES = ["info", "warning", "error"] as const;
 export const DOC_DRIFT_STATUSES = ["ok", "drifted"] as const;
@@ -13,27 +13,17 @@ export const DOC_DRIFT_STATUSES = ["ok", "drifted"] as const;
 export type DocDriftSeverity = (typeof DOC_DRIFT_SEVERITIES)[number];
 export type DocDriftStatus = (typeof DOC_DRIFT_STATUSES)[number];
 
-export const DocDriftFindingSchema = Type.Object(
-  {
-    file: Type.String({ minLength: 1 }),
-    description: Type.String({ minLength: 1 }),
-    severity: Type.Union(
-      DOC_DRIFT_SEVERITIES.map((value) => Type.Literal(value)),
-    ),
-    relatedFiles: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-  },
-  { additionalProperties: false },
-);
+export const DocDriftFindingSchema = z.object({
+  file: z.string().min(1),
+  description: z.string().min(1),
+  severity: z.enum(DOC_DRIFT_SEVERITIES),
+  relatedFiles: z.array(z.string().min(1)).optional(),
+}).strict();
 
-export const DocDriftOutputSchema = Type.Object(
-  {
-    findings: Type.Array(DocDriftFindingSchema),
-    status: Type.Union(
-      DOC_DRIFT_STATUSES.map((value) => Type.Literal(value)),
-    ),
-  },
-  { additionalProperties: false },
-);
+export const DocDriftOutputSchema = z.object({
+  findings: z.array(DocDriftFindingSchema),
+  status: z.enum(DOC_DRIFT_STATUSES),
+}).strict();
 
-export type DocDriftFinding = Static<typeof DocDriftFindingSchema>;
-export type DocDriftOutput = Static<typeof DocDriftOutputSchema>;
+export type DocDriftFinding = z.infer<typeof DocDriftFindingSchema>;
+export type DocDriftOutput = z.infer<typeof DocDriftOutputSchema>;

package/src/fix-pr/assessment.ts

@@ -29,6 +29,8 @@ export interface RunFixPrAssessmentInput {
   model?: string;
   thinkingLevel?: string | null;
   maxAttempts?: number;
+  timeoutMs?: number;
+  maxCommentsPerBatch?: number;
 }
 
 interface BuildAssessmentPromptArgs {
@@ -74,6 +76,19 @@ function buildAssessmentPrompt(args: BuildAssessmentPromptArgs): string {
   ].join("\n");
 }
 
+function chunkComments(comments: readonly PrComment[], maxCommentsPerBatch: number): PrComment[][] {
+  if (maxCommentsPerBatch <= 0 || comments.length <= maxCommentsPerBatch) {
+    return [[...comments]];
+  }
+
+  const chunks: PrComment[][] = [];
+  for (let index = 0; index < comments.length; index += maxCommentsPerBatch) {
+    chunks.push(comments.slice(index, index + maxCommentsPerBatch));
+  }
+  return chunks;
+}
+
+
 /**
  * Run a schema-backed assessment over a cluster of PR comments.
  *
@@ -93,30 +108,54 @@ export async function runFixPrAssessment(
   }
 
   const schemaText = renderSchemaText(FixPrAssessmentBatchSchema);
-  const prompt = buildAssessmentPrompt({
-    schemaText,
-    comments: input.comments,
-    repo: input.repo,
-    prNumber: input.prNumber,
-    selectedTargetLabel: input.selectedTargetLabel,
-  });
-
-  return runWithOutputValidation<FixPrAssessmentBatch>(
-    input.createAgentSession as any,
-    {
-      cwd: input.cwd,
-      prompt,
-      schema: schemaText,
-      parse: (raw) =>
-        parseStructuredOutput<FixPrAssessmentBatch>(raw, FixPrAssessmentBatchSchema),
-      model: input.model,
-      thinkingLevel: input.thinkingLevel ?? null,
-      maxAttempts: input.maxAttempts,
-      reliability: input.paths
-        ? { paths: input.paths, cwd: input.cwd, command: "fix-pr", operation: "assessment" }
-        : undefined,
-    },
-  );
+  const maxCommentsPerBatch = input.maxCommentsPerBatch ?? input.comments.length;
+  const commentChunks = chunkComments(input.comments, maxCommentsPerBatch);
+  const assessments: FixPrAssessmentBatch["assessments"] = [];
+  const rawOutputs: string[] = [];
+  let attempts = 0;
+
+  for (const comments of commentChunks) {
+    const prompt = buildAssessmentPrompt({
+      schemaText,
+      comments,
+      repo: input.repo,
+      prNumber: input.prNumber,
+      selectedTargetLabel: input.selectedTargetLabel,
+    });
+
+    const result = await runWithOutputValidation<FixPrAssessmentBatch>(
+      input.createAgentSession as any,
+      {
+        cwd: input.cwd,
+        prompt,
+        schema: schemaText,
+        parse: (raw) =>
+          parseStructuredOutput<FixPrAssessmentBatch>(raw, FixPrAssessmentBatchSchema),
+        model: input.model,
+        thinkingLevel: input.thinkingLevel ?? null,
+        maxAttempts: input.maxAttempts,
+        timeoutMs: input.timeoutMs,
+        reliability: input.paths
+          ? { paths: input.paths, cwd: input.cwd, command: "fix-pr", operation: "assessment" }
+          : undefined,
+      },
+    );
+
+    attempts += result.attempts;
+    if (result.status === "blocked") {
+      return { ...result, attempts };
+    }
+
+    rawOutputs.push(result.rawOutput);
+    assessments.push(...result.output.assessments);
+  }
+
+  return {
+    status: "ok",
+    output: { assessments },
+    rawOutput: rawOutputs.join("\n"),
+    attempts,
+  };
 }
 
 /**

package/src/fix-pr/contracts.ts

@@ -5,35 +5,27 @@
 // against FixPrAssessmentBatchSchema; downstream work batches are derived
 // from this validated artifact, not from ad-hoc orchestration prose.
 
-import { Type, type Static } from "@sinclair/typebox";
+import { z } from "zod/v4"
 
 export const FIX_PR_ASSESSMENT_VERDICTS = ["apply", "reject", "investigate"] as const;
 export type FixPrAssessmentVerdict = (typeof FIX_PR_ASSESSMENT_VERDICTS)[number];
 
-export const FixPrCommentAssessmentSchema = Type.Object(
-  {
-    commentId: Type.Integer(),
-    verdict: Type.Union(
-      FIX_PR_ASSESSMENT_VERDICTS.map((value) => Type.Literal(value)),
-    ),
-    rationale: Type.String({ minLength: 1 }),
-    affectedFiles: Type.Array(Type.String({ minLength: 1 })),
-    rippleEffects: Type.Array(Type.String({ minLength: 1 })),
-    verificationPlan: Type.String({ minLength: 1 }),
-  },
-  { additionalProperties: false },
-);
+export const FixPrCommentAssessmentSchema = z.object({
+  commentId: z.number().int(),
+  verdict: z.enum(FIX_PR_ASSESSMENT_VERDICTS),
+  rationale: z.string().min(1),
+  affectedFiles: z.array(z.string().min(1)),
+  rippleEffects: z.array(z.string().min(1)),
+  verificationPlan: z.string().min(1),
+}).strict();
 
-export const FixPrAssessmentBatchSchema = Type.Object(
-  {
-    assessments: Type.Array(FixPrCommentAssessmentSchema),
-    summary: Type.Optional(Type.String()),
-  },
-  { additionalProperties: false },
-);
+export const FixPrAssessmentBatchSchema = z.object({
+  assessments: z.array(FixPrCommentAssessmentSchema),
+  summary: z.string().optional(),
+}).strict();
 
-export type FixPrCommentAssessment = Static<typeof FixPrCommentAssessmentSchema>;
-export type FixPrAssessmentBatch = Static<typeof FixPrAssessmentBatchSchema>;
+export type FixPrCommentAssessment = z.infer<typeof FixPrCommentAssessmentSchema>;
+export type FixPrAssessmentBatch = z.infer<typeof FixPrAssessmentBatchSchema>;
 
 /**
  * A deterministic execution unit derived from a validated FixPrAssessmentBatch.

package/src/fix-pr/fetch-comments.ts

@@ -11,6 +11,30 @@ const INLINE_COMMENTS_JQ =
 const REVIEW_COMMENTS_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}';
 
+
+const RESOLVED_REVIEW_THREAD_COMMENT_IDS_QUERY = `
+query($owner: String!, $name: String!, $number: Int!, $endCursor: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 100, after: $endCursor) {
+        nodes {
+          isResolved
+          comments(first: 100) {
+            nodes {
+              databaseId
+            }
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  }
+}
+`;
+
 export interface ClusteredPrComments<TTarget extends WorkspaceTarget = WorkspaceTarget> {
   allComments: PrComment[];
   commentsByTargetId: Map<string, PrComment[]>;
@@ -27,6 +51,30 @@ function appendComment(commentsByTargetId: Map<string, PrComment[]>, targetId: s
   commentsByTargetId.set(targetId, [comment]);
 }
 
+
+function parseRepoOwnerAndName(repo: string): { owner: string; name: string } | null {
+  const separator = repo.indexOf("/");
+  if (separator <= 0 || separator === repo.length - 1) {
+    return null;
+  }
+
+  return {
+    owner: repo.slice(0, separator),
+    name: repo.slice(separator + 1),
+  };
+}
+
+function parseResolvedCommentIds(output: string): Set<number> {
+  const ids = new Set<number>();
+  for (const line of output.split(/\r?\n/)) {
+    const id = Number.parseInt(line.trim(), 10);
+    if (Number.isInteger(id)) {
+      ids.add(id);
+    }
+  }
+  return ids;
+}
+
 export function parsePrCommentsJsonl(content: string): PrComment[] {
   return content
     .split(/\r?\n/)
@@ -49,6 +97,68 @@ export function stringifyPrCommentsJsonl(comments: readonly PrComment[]): string
   return `${comments.map((comment) => JSON.stringify(comment)).join("\n")}\n`;
 }
 
+async function fetchResolvedReviewThreadCommentIds(
+  platform: Platform,
+  repo: string,
+  prNumber: number,
+  cwd: string,
+): Promise<Set<number> | string> {
+  const repoParts = parseRepoOwnerAndName(repo);
+  if (!repoParts) {
+    return `Invalid repository name: ${repo}`;
+  }
+
+  const result = await platform.exec(
+    "gh",
+    [
+      "api",
+      "graphql",
+      "--paginate",
+      "-f",
+      `query=${RESOLVED_REVIEW_THREAD_COMMENT_IDS_QUERY}`,
+      "-F",
+      `owner=${repoParts.owner}`,
+      "-F",
+      `name=${repoParts.name}`,
+      "-F",
+      `number=${prNumber}`,
+      "--jq",
+      ".data.repository.pullRequest.reviewThreads.nodes[] | select(.isResolved == true) | .comments.nodes[].databaseId",
+    ],
+    { cwd },
+  );
+
+  if (result.code !== 0) {
+    return result.stderr || "gh api graphql failed while fetching resolved review threads";
+  }
+
+  return parseResolvedCommentIds(result.stdout);
+}
+
+function filterResolvedComments(content: string, resolvedCommentIds: ReadonlySet<number>): string {
+  if (!content.trim() || resolvedCommentIds.size === 0) {
+    return content;
+  }
+
+  const unresolvedLines = content
+    .split(/\r?\n/)
+    .filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        return false;
+      }
+      try {
+        const comment = JSON.parse(trimmed) as Pick<PrComment, "id">;
+        return !resolvedCommentIds.has(comment.id);
+      } catch {
+        return true;
+      }
+    });
+
+  return unresolvedLines.length > 0 ? `${unresolvedLines.join("\n")}\n` : "";
+}
+
+
 export function clusterPrCommentsByTarget<TTarget extends WorkspaceTarget>(
   targets: readonly TTarget[],
   comments: readonly PrComment[],
@@ -143,4 +253,13 @@ export async function fetchPrComments(
   if (inlineResult.code !== 0 && reviewResult.code !== 0) {
     return inlineResult.stderr || reviewResult.stderr || "gh api calls failed";
   }
+
+  const resolvedCommentIds = await fetchResolvedReviewThreadCommentIds(platform, repo, prNumber, cwd);
+  if (typeof resolvedCommentIds === "string") {
+    return resolvedCommentIds;
+  }
+
+  if (resolvedCommentIds.size > 0) {
+    fs.writeFileSync(outputPath, filterResolvedComments(fs.readFileSync(outputPath, "utf-8"), resolvedCommentIds));
+  }
 }