poe-code 3.0.337 → 3.0.338

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "3.0.337",
+  "version": "3.0.338",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "type": "module",
   "main": "./dist/index.js",

package/packages/github-review/dist/diff.d.ts

@@ -1,6 +1,7 @@
 export interface ReviewInlineComment {
     path: string;
     line: number;
+    side?: "LEFT" | "RIGHT";
     body: string;
 }
 export interface ReviewDiffLine {
@@ -23,6 +24,8 @@ export interface ReviewDiffContext {
     files: ReviewDiffFile[];
     fileOrder: Map<string, number>;
     reviewableLinesByPath: Map<string, Set<number>>;
+    leftLinesByPath: Map<string, Set<number>>;
+    rightContextLinesByPath: Map<string, Set<number>>;
     rendered: string;
 }
 export declare function parseReviewDiff(diffText: string): ReviewDiffContext;

package/packages/github-review/dist/diff.js

@@ -121,6 +121,8 @@ export function parseReviewDiff(diffText) {
                 status: "modified",
                 hunks: [],
                 reviewableLines: [],
+                leftLineSet: new Set(),
+                rightContextLineSet: new Set(),
                 reviewableLineSet: new Set()
             };
             continue;
@@ -173,11 +175,13 @@ export function parseReviewDiff(diffText) {
         }
         if (line.startsWith("-") && !line.startsWith("---")) {
             currentHunk.lines.push({ side: "LEFT", line: oldLine, text: line });
+            currentFile.leftLineSet.add(oldLine);
             oldLine += 1;
             continue;
         }
         if (line.startsWith(" ")) {
             currentHunk.lines.push({ side: "RIGHT", line: newLine, text: line });
+            currentFile.rightContextLineSet.add(newLine);
             currentFile.reviewableLineSet.add(newLine);
             oldLine += 1;
             newLine += 1;
@@ -195,6 +199,8 @@ export function parseReviewDiff(diffText) {
         files: publicFiles,
         fileOrder: new Map(publicFiles.map((file, index) => [file.path, index])),
         reviewableLinesByPath: new Map(files.map((file) => [file.path, file.reviewableLineSet])),
+        leftLinesByPath: new Map(files.map((file) => [file.path, file.leftLineSet])),
+        rightContextLinesByPath: new Map(files.map((file) => [file.path, file.rightContextLineSet])),
         rendered: publicFiles.map(renderReviewFile).join("\n\n")
     };
 }
@@ -202,18 +208,31 @@ export function validateInlineComments(comments, context) {
     const accepted = [];
     const seen = new Set();
     for (const comment of comments) {
-        const path = comment.path.trim();
+        const path = comment.path;
         const body = comment.body.trim();
-        if (!path || !body || !Number.isInteger(comment.line) || comment.line < 1) {
+        if (path.length === 0 || !body || !Number.isInteger(comment.line) || comment.line < 1) {
             throw new Error("Inline review comments require path, positive line, and body.");
         }
+        if (comment.side === "LEFT") {
+            throw new Error(`Inline comment target ${path}:${comment.line} is a left-side diff target; only right-side comments are supported.`);
+        }
         if (!context.reviewableLinesByPath.get(path)?.has(comment.line)) {
             throw new Error(`Inline comment target ${path}:${comment.line} is not a valid right-side diff target.`);
         }
+        if (!comment.side &&
+            context.leftLinesByPath.get(path)?.has(comment.line) &&
+            context.rightContextLinesByPath.get(path)?.has(comment.line)) {
+            throw new Error(`Inline comment target ${path}:${comment.line} is ambiguous; specify side RIGHT to target the right-side diff line.`);
+        }
         const key = `${path}\0${comment.line}\0${body}`;
         if (!seen.has(key)) {
             seen.add(key);
-            accepted.push({ path, line: comment.line, body });
+            accepted.push({
+                path,
+                line: comment.line,
+                ...(comment.side ? { side: comment.side } : {}),
+                body
+            });
         }
     }
     accepted.sort((left, right) => {

package/packages/github-review/dist/gh.js

@@ -54,12 +54,13 @@ function parseJson(stdout, action) {
     }
 }
 export function ghPrView(prUrl, fields, options = {}) {
-    requirePullRequestRef(prUrl);
+    const ref = requirePullRequestRef(prUrl);
+    const canonicalPrUrl = ref.url;
     const requestedFields = dedupe([...fields]);
-    const result = runGh(["pr", "view", prUrl, "--json", requestedFields.join(",")], options);
+    const result = runGh(["pr", "view", canonicalPrUrl, "--json", requestedFields.join(",")], options);
     if (result.code === 0) {
         const parsed = parseJsonRecord(result.stdout, "gh pr view");
-        parsed.url ??= prUrl;
+        parsed.url ??= canonicalPrUrl;
         return parsed;
     }
     const availableFields = parseGhAvailableFields(result.stderr);
@@ -67,17 +68,17 @@ export function ghPrView(prUrl, fields, options = {}) {
     if (fallbackFields.length === 0 || fallbackFields.length === requestedFields.length) {
         throw new Error(result.stderr.trim() || result.stdout.trim() || "gh pr view failed");
     }
-    const fallback = runGh(["pr", "view", prUrl, "--json", fallbackFields.join(",")], options);
+    const fallback = runGh(["pr", "view", canonicalPrUrl, "--json", fallbackFields.join(",")], options);
     if (fallback.code !== 0) {
         throw new Error(fallback.stderr.trim() || fallback.stdout.trim() || "gh pr view failed");
     }
     const parsed = parseJsonRecord(fallback.stdout, "gh pr view");
-    parsed.url ??= prUrl;
+    parsed.url ??= canonicalPrUrl;
     return parsed;
 }
 export function ghPrDiff(prUrl, options = {}) {
-    requirePullRequestRef(prUrl);
-    return runGhOrThrow(["pr", "diff", prUrl], options);
+    const ref = requirePullRequestRef(prUrl);
+    return runGhOrThrow(["pr", "diff", ref.url], options);
 }
 export function ghApiJson(prUrl, args, payload, options = {}) {
     const ref = requirePullRequestRef(prUrl);

package/packages/github-review/dist/pr-url.js

@@ -1,6 +1,6 @@
 function parseUrl(value) {
     try {
-        return new URL(value);
+        return new URL(value.trim());
     }
     catch {
         return null;
@@ -22,6 +22,9 @@ function parsePathPart(value) {
         return null;
     }
 }
+function formatPullRequestUrl(ref) {
+    return `https://${ref.host}/${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.repo)}/pull/${ref.number}`;
+}
 export function parseGitHubPullRequestRef(prUrl) {
     const parsed = parseUrl(prUrl);
     if (!parsed ||
@@ -41,18 +44,18 @@ export function parseGitHubPullRequestRef(prUrl) {
     if (!owner || !repo || !Number.isSafeInteger(number) || number <= 0) {
         return null;
     }
-    return {
+    const ref = {
         host: parsed.host.toLowerCase(),
         owner,
         repo,
-        number,
-        url: prUrl
+        number
     };
+    return { ...ref, url: formatPullRequestUrl(ref) };
 }
 export function canonicalPullRequestUrl(prUrl) {
     const ref = parseGitHubPullRequestRef(prUrl);
     if (!ref) {
         return prUrl;
     }
-    return `https://${ref.host}/${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.repo)}/pull/${ref.number}`;
+    return ref.url;
 }

package/packages/github-review/dist/review-history.js

@@ -76,11 +76,32 @@ function isAtOrAfter(value, since) {
         return false;
     return new Date(value).getTime() >= new Date(since).getTime();
 }
-function createdAt(record, kind) {
+function rawCreatedAt(record, kind) {
     return kind === "review_body"
         ? (text(record, "submitted_at") ?? text(record, "created_at"))
         : (text(record, "created_at") ?? text(record, "submitted_at"));
 }
+function createdAt(record, kind) {
+    const value = rawCreatedAt(record, kind);
+    if (!value) {
+        return null;
+    }
+    const timestamp = new Date(value);
+    if (Number.isNaN(timestamp.getTime())) {
+        throw new Error(`Invalid GitHub review-history ${kind} timestamp: ${value}`);
+    }
+    return timestamp.toISOString();
+}
+function dedupeRepos(repos) {
+    const deduped = new Map();
+    for (const repo of repos) {
+        const key = repo.toLowerCase();
+        if (!deduped.has(key)) {
+            deduped.set(key, repo);
+        }
+    }
+    return [...deduped.values()];
+}
 class ReviewHistoryFetcher {
     options;
     runner;
@@ -314,7 +335,7 @@ export async function* fetchReviewHistory(options) {
         (!Number.isInteger(options.maxComments) || options.maxComments < 1)) {
         throw new Error("Review-history maxComments must be a positive integer.");
     }
-    const repos = [...new Set(options.repos)];
+    const repos = dedupeRepos(options.repos);
     for (const repo of repos) {
         if (!validRepo(repo)) {
             throw new Error(`Invalid GitHub repository name: ${repo}`);

package/packages/github-review/dist/review.js

@@ -35,18 +35,21 @@ function requirePositiveId(commentId) {
     }
     return normalized;
 }
-function validateReviewComments(comments) {
-    for (const comment of comments) {
-        if (!comment.path.trim()) {
+function normalizeReviewComments(comments) {
+    return comments.map((comment) => {
+        const path = comment.path.trim();
+        const body = comment.body.trim();
+        if (!path) {
             throw new Error("Review comment path must be non-empty.");
         }
         if (!Number.isSafeInteger(comment.line) || comment.line <= 0) {
             throw new Error("Review comment line must be a positive integer.");
         }
-        if (!comment.body.trim()) {
+        if (!body) {
             throw new Error("Review comment body must be non-empty.");
         }
-    }
+        return { path, line: comment.line, body };
+    });
 }
 function submissionFromResponse(response) {
     return {
@@ -59,8 +62,7 @@ export function submitPullRequestReview(input) {
     if (!REVIEW_DECISIONS.has(input.decision)) {
         throw new Error(`Invalid pull request review decision: ${input.decision}`);
     }
-    const comments = input.comments ?? [];
-    validateReviewComments(comments);
+    const comments = normalizeReviewComments(input.comments ?? []);
     const response = ghApiJson(prUrl, ["--method", "POST", reviewEndpoint(prUrl)], {
         body: input.summary,
         event: input.decision,
@@ -75,10 +77,11 @@ export function submitPullRequestReview(input) {
 }
 export function editPullRequestReviewComment(input) {
     const prUrl = inputPullRequestUrl(input);
-    if (!input.body.trim()) {
+    const body = input.body.trim();
+    if (!body) {
         throw new Error("Review comment body must be non-empty.");
     }
-    const response = ghApiJson(prUrl, ["--method", "PATCH", commentEndpoint(prUrl, input.commentId)], { body: input.body }, input);
+    const response = ghApiJson(prUrl, ["--method", "PATCH", commentEndpoint(prUrl, input.commentId)], { body }, input);
     return submissionFromResponse(response);
 }
 export function deletePullRequestReviewComment(input) {