@plannotator/pi-extension 0.16.7 → 0.17.1

package/generated/codex-review.ts

@@ -0,0 +1,382 @@
+// @generated — DO NOT EDIT. Source: packages/server/codex-review.ts
+/**
+ * Codex Review Agent — prompt, command builder, output parser, and finding transformer.
+ *
+ * Encapsulates all Codex-specific logic for the AI review agent integration.
+ * The review server (review.ts) calls into this module via the agent-jobs callbacks.
+ */
+
+import { join } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { appendFile, mkdir, unlink, writeFile, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import type { DiffType } from "./review-core.js";
+import type { PRMetadata } from "./pr-provider.js";
+import { toRelativePath } from "./path-utils.js";
+
+// ---------------------------------------------------------------------------
+// Debug log — only active when PLANNOTATOR_DEBUG is set
+// ---------------------------------------------------------------------------
+
+const DEBUG_ENABLED = !!process.env.PLANNOTATOR_DEBUG;
+const DEBUG_LOG_PATH = join(homedir(), ".plannotator", "codex-review-debug.log");
+
+async function debugLog(label: string, data?: unknown): Promise<void> {
+  if (!DEBUG_ENABLED) return;
+  try {
+    await mkdir(join(homedir(), ".plannotator"), { recursive: true });
+    const timestamp = new Date().toISOString();
+    const line = data !== undefined
+      ? `[${timestamp}] ${label}: ${typeof data === "string" ? data : JSON.stringify(data, null, 2)}\n`
+      : `[${timestamp}] ${label}\n`;
+    await appendFile(DEBUG_LOG_PATH, line);
+  } catch { /* never fail the main flow */ }
+}
+
+// ---------------------------------------------------------------------------
+// Schema — embedded as a string, written to disk on first use.
+// Bun's compiled binary uses a virtual FS that external processes (codex)
+// can't read, so we materialize the schema to a real file.
+// ---------------------------------------------------------------------------
+
+const CODEX_REVIEW_SCHEMA = JSON.stringify({
+  type: "object",
+  properties: {
+    findings: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+          body: { type: "string" },
+          confidence_score: { type: "number" },
+          priority: { type: ["integer", "null"] },
+          code_location: {
+            type: "object",
+            properties: {
+              absolute_file_path: { type: "string" },
+              line_range: {
+                type: "object",
+                properties: {
+                  start: { type: "integer" },
+                  end: { type: "integer" },
+                },
+                required: ["start", "end"],
+                additionalProperties: false,
+              },
+            },
+            required: ["absolute_file_path", "line_range"],
+            additionalProperties: false,
+          },
+        },
+        required: ["title", "body", "confidence_score", "priority", "code_location"],
+        additionalProperties: false,
+      },
+    },
+    overall_correctness: { type: "string" },
+    overall_explanation: { type: "string" },
+    overall_confidence_score: { type: "number" },
+  },
+  required: ["findings", "overall_correctness", "overall_explanation", "overall_confidence_score"],
+  additionalProperties: false,
+});
+
+const SCHEMA_DIR = join(homedir(), ".plannotator");
+const SCHEMA_FILE = join(SCHEMA_DIR, "codex-review-schema.json");
+let schemaMaterialized = false;
+
+/** Ensure the schema file exists on disk and return its path. */
+async function ensureSchemaFile(): Promise<string> {
+  if (!schemaMaterialized) {
+    await mkdir(SCHEMA_DIR, { recursive: true });
+    await writeFile(SCHEMA_FILE, CODEX_REVIEW_SCHEMA);
+    schemaMaterialized = true;
+  }
+  return SCHEMA_FILE;
+}
+
+export { SCHEMA_FILE as CODEX_REVIEW_SCHEMA_PATH };
+
+// ---------------------------------------------------------------------------
+// System prompt — copied verbatim from codex-rs/core/review_prompt.md
+// ---------------------------------------------------------------------------
+
+export const CODEX_REVIEW_SYSTEM_PROMPT = `# Review guidelines:
+
+You are acting as a reviewer for a proposed code change made by another engineer.
+
+Below are some default guidelines for determining whether the original author would appreciate the issue being flagged.
+
+These are not the final word in determining whether an issue is a bug. In many cases, you will encounter other, more specific guidelines. These may be present elsewhere in a developer message, a user message, a file, or even elsewhere in this system message.
+Those guidelines should be considered to override these general instructions.
+
+Here are the general guidelines for determining whether something is a bug and should be flagged.
+
+1. It meaningfully impacts the accuracy, performance, security, or maintainability of the code.
+2. The bug is discrete and actionable (i.e. not a general issue with the codebase or a combination of multiple issues).
+3. Fixing the bug does not demand a level of rigor that is not present in the rest of the codebase (e.g. one doesn't need very detailed comments and input validation in a repository of one-off scripts in personal projects)
+4. The bug was introduced in the commit (pre-existing bugs should not be flagged).
+5. The author of the original PR would likely fix the issue if they were made aware of it.
+6. The bug does not rely on unstated assumptions about the codebase or author's intent.
+7. It is not enough to speculate that a change may disrupt another part of the codebase, to be considered a bug, one must identify the other parts of the code that are provably affected.
+8. The bug is clearly not just an intentional change by the original author.
+
+When flagging a bug, you will also provide an accompanying comment. Once again, these guidelines are not the final word on how to construct a comment -- defer to any subsequent guidelines that you encounter.
+
+1. The comment should be clear about why the issue is a bug.
+2. The comment should appropriately communicate the severity of the issue. It should not claim that an issue is more severe than it actually is.
+3. The comment should be brief. The body should be at most 1 paragraph. It should not introduce line breaks within the natural language flow unless it is necessary for the code fragment.
+4. The comment should not include any chunks of code longer than 3 lines. Any code chunks should be wrapped in markdown inline code tags or a code block.
+5. The comment should clearly and explicitly communicate the scenarios, environments, or inputs that are necessary for the bug to arise. The comment should immediately indicate that the issue's severity depends on these factors.
+6. The comment's tone should be matter-of-fact and not accusatory or overly positive. It should read as a helpful AI assistant suggestion without sounding too much like a human reviewer.
+7. The comment should be written such that the original author can immediately grasp the idea without close reading.
+8. The comment should avoid excessive flattery and comments that are not helpful to the original author. The comment should avoid phrasing like "Great job ...", "Thanks for ...".
+
+Below are some more detailed guidelines that you should apply to this specific review.
+
+HOW MANY FINDINGS TO RETURN:
+
+Output all findings that the original author would fix if they knew about it. If there is no finding that a person would definitely love to see and fix, prefer outputting no findings. Do not stop at the first qualifying finding. Continue until you've listed every qualifying finding.
+
+GUIDELINES:
+
+- Ignore trivial style unless it obscures meaning or violates documented standards.
+- Use one comment per distinct issue (or a multi-line range if necessary).
+- Use \`\`\`suggestion blocks ONLY for concrete replacement code (minimal lines; no commentary inside the block).
+- In every \`\`\`suggestion block, preserve the exact leading whitespace of the replaced lines (spaces vs tabs, number of spaces).
+- Do NOT introduce or remove outer indentation levels unless that is the actual fix.
+
+The comments will be presented in the code review as inline comments. You should avoid providing unnecessary location details in the comment body. Always keep the line range as short as possible for interpreting the issue. Avoid ranges longer than 5–10 lines; instead, choose the most suitable subrange that pinpoints the problem.
+
+At the beginning of the finding title, tag the bug with priority level. For example "[P1] Un-padding slices along wrong tensor dimensions". [P0] – Drop everything to fix.  Blocking release, operations, or major usage. Only use for universal issues that do not depend on any assumptions about the inputs. · [P1] – Urgent. Should be addressed in the next cycle · [P2] – Normal. To be fixed eventually · [P3] – Low. Nice to have.
+
+Additionally, include a numeric priority field in the JSON output for each finding: set "priority" to 0 for P0, 1 for P1, 2 for P2, or 3 for P3. If a priority cannot be determined, omit the field or use null.
+
+At the end of your findings, output an "overall correctness" verdict of whether or not the patch should be considered "correct".
+Correct implies that existing code and tests will not break, and the patch is free of bugs and other blocking issues.
+Ignore non-blocking issues such as style, formatting, typos, documentation, and other nits.
+
+FORMATTING GUIDELINES:
+The finding description should be one paragraph.`;
+
+// ---------------------------------------------------------------------------
+// User message builder
+// ---------------------------------------------------------------------------
+
+/** Build the dynamic user message based on review context. */
+export function buildCodexReviewUserMessage(
+  patch: string,
+  diffType: DiffType,
+  options?: { defaultBranch?: string; hasLocalAccess?: boolean },
+  prMetadata?: PRMetadata,
+): string {
+  // PR/MR mode — pass the link, with local context if --local
+  if (prMetadata) {
+    if (options?.hasLocalAccess) {
+      return [
+        prMetadata.url,
+        "",
+        "You are in a local worktree checked out at the PR head. The code is available locally.",
+        `To see the PR changes, diff against the remote base branch: git diff origin/${prMetadata.baseBranch}...HEAD`,
+        "Do NOT diff against the local `main` branch — it may be stale. Always use origin/.",
+      ].join("\n");
+    }
+    return prMetadata.url;
+  }
+
+  // Local mode — Codex has full file/git access
+  const effectiveDiffType = diffType.startsWith("worktree:")
+    ? diffType.split(":").pop() || "uncommitted"
+    : diffType;
+
+  switch (effectiveDiffType) {
+    case "uncommitted":
+      return "Review the current code changes (staged, unstaged, and untracked files) and provide prioritized findings.";
+
+    case "staged":
+      return "Review the currently staged code changes (`git diff --staged`) and provide prioritized findings.";
+
+    case "unstaged":
+      return "Review the unstaged code changes (tracked modifications and untracked files) and provide prioritized findings.";
+
+    case "last-commit":
+      return "Review the code changes introduced in the last commit (`git diff HEAD~1..HEAD`) and provide prioritized findings.";
+
+    case "branch": {
+      const base = options?.defaultBranch || "main";
+      return `Review the code changes against the base branch '${base}'. Run \`git diff ${base}..HEAD\` to inspect the changes. Provide prioritized, actionable findings.`;
+    }
+
+    default:
+      // p4 or unknown — fall back to generic with inlined diff
+      return [
+        "Review the following code changes and provide prioritized findings.",
+        "",
+        "```diff",
+        patch,
+        "```",
+      ].join("\n");
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Command builder
+// ---------------------------------------------------------------------------
+
+export interface CodexCommandOptions {
+  cwd: string;
+  outputPath: string;
+  prompt: string;
+}
+
+/** Build the `codex exec` argv array. Materializes the schema file on first call. */
+export async function buildCodexCommand(options: CodexCommandOptions): Promise<string[]> {
+  const { cwd, outputPath, prompt } = options;
+  const schemaPath = await ensureSchemaFile();
+
+  const command = [
+    "codex",
+    "exec",
+    "--output-schema", schemaPath,
+    "-o", outputPath,
+    "--full-auto",
+    "--ephemeral",
+    "-C", cwd,
+    prompt,
+  ];
+
+  debugLog("BUILD_COMMAND", {
+    cwd,
+    outputPath,
+    schemaPath,
+    promptLength: prompt.length,
+    command: command.map((c, i) => i === command.length - 1 ? `<prompt: ${c.length} chars>` : c),
+  });
+
+  return command;
+}
+
+/** Generate a unique temp file path for Codex output. */
+export function generateOutputPath(): string {
+  return join(tmpdir(), `plannotator-codex-${crypto.randomUUID()}.json`);
+}
+
+// ---------------------------------------------------------------------------
+// Output parsing — matches Codex's native ReviewOutputEvent schema
+// ---------------------------------------------------------------------------
+
+export interface CodexCodeLocation {
+  absolute_file_path: string;
+  line_range: { start: number; end: number };
+}
+
+export interface CodexFinding {
+  title: string;
+  body: string;
+  confidence_score: number;
+  priority: number | null;
+  code_location: CodexCodeLocation;
+}
+
+export interface CodexReviewOutput {
+  findings: CodexFinding[];
+  overall_correctness: string;
+  overall_explanation: string;
+  overall_confidence_score: number;
+}
+
+/** Read and parse the Codex -o output file. Returns null on any failure. */
+export async function parseCodexOutput(outputPath: string): Promise<CodexReviewOutput | null> {
+  await debugLog("PARSE_OUTPUT_START", { outputPath });
+
+  try {
+    if (!existsSync(outputPath)) {
+      await debugLog("PARSE_OUTPUT_FILE_MISSING", outputPath);
+      return null;
+    }
+
+    const text = await readFile(outputPath, "utf-8");
+
+    // Clean up temp file
+    try { await unlink(outputPath); } catch { /* ignore */ }
+
+    if (!text.trim()) {
+      await debugLog("PARSE_OUTPUT_EMPTY");
+      return null;
+    }
+
+    const parsed = JSON.parse(text);
+    if (!parsed || !Array.isArray(parsed.findings)) {
+      await debugLog("PARSE_OUTPUT_INVALID_SHAPE", { hasFindings: !!parsed?.findings });
+      return null;
+    }
+
+    await debugLog("PARSE_OUTPUT_SUCCESS", {
+      findingsCount: parsed.findings.length,
+      overall_correctness: parsed.overall_correctness,
+      overall_confidence_score: parsed.overall_confidence_score,
+    });
+
+    return parsed as CodexReviewOutput;
+  } catch (err) {
+    await debugLog("PARSE_OUTPUT_ERROR", err instanceof Error ? err.message : String(err));
+    // Clean up on error too
+    try { await unlink(outputPath); } catch { /* ignore */ }
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Finding → external annotation transform
+// ---------------------------------------------------------------------------
+
+export interface ReviewAnnotationInput {
+  source: string;
+  filePath: string;
+  lineStart: number;
+  lineEnd: number;
+  type: string;
+  side: string;
+  scope: string;
+  text: string;
+  author: string;
+}
+
+/** Transform review findings (provider-agnostic) into the external annotation format. */
+export function transformReviewFindings(
+  findings: CodexFinding[],
+  source: string,
+  cwd?: string,
+  author?: string,
+): ReviewAnnotationInput[] {
+  const annotations = findings
+    .filter((f) =>
+      f.code_location?.absolute_file_path &&
+      typeof f.code_location?.line_range?.start === "number" &&
+      typeof f.code_location?.line_range?.end === "number"
+    )
+    .map((f) => ({
+      source,
+      filePath: toRelativePath(f.code_location.absolute_file_path, cwd),
+      lineStart: f.code_location.line_range.start,
+      lineEnd: f.code_location.line_range.end,
+      type: "comment",
+      side: "new",
+      scope: "line",
+      text: `${f.title}\n\n${f.body}`.trim(),
+      author: author ?? "Review Agent",
+    }));
+
+  debugLog("TRANSFORM_FINDINGS", {
+    inputCount: findings.length,
+    outputCount: annotations.length,
+    annotations: annotations.map((a) => ({
+      filePath: a.filePath,
+      lineStart: a.lineStart,
+      lineEnd: a.lineEnd,
+      textPreview: a.text.slice(0, 80),
+    })),
+  });
+
+  return annotations;
+}

package/generated/external-annotation.ts

@@ -181,6 +181,9 @@ interface ReviewAnnotation {
   createdAt: number;
   author?: string;
   source?: string;
+  // Agent review metadata (optional — only set by Claude review findings)
+  severity?: string; // "important" | "nit" | "pre_existing"
+  reasoning?: string; // Validation chain explaining how the issue was confirmed
 }
 
 const VALID_REVIEW_TYPES = ["comment", "suggestion", "concern"];
@@ -255,6 +258,9 @@ export function transformReviewInput(
       createdAt: Date.now(),
       author: typeof obj.author === "string" ? obj.author : undefined,
       source,
+      // Agent review metadata (optional — only set by Claude review findings)
+      ...(typeof obj.severity === "string" && { severity: obj.severity }),
+      ...(typeof obj.reasoning === "string" && { reasoning: obj.reasoning }),
     });
   }
 

package/generated/path-utils.ts

@@ -0,0 +1,19 @@
+// @generated — DO NOT EDIT. Source: packages/server/path-utils.ts
+/**
+ * Strip a cwd prefix from an absolute path to get a repo-relative path.
+ * Used by review agent transforms to convert absolute file paths from
+ * agent output into diff-compatible relative paths.
+ *
+ * Uses path.relative for cross-platform support (Windows backslashes)
+ * and normalizes to forward slashes for git diff path matching.
+ */
+import { relative } from "node:path";
+
+export function toRelativePath(absolutePath: string, cwd?: string): string {
+  if (!cwd) return absolutePath;
+  const rel = relative(cwd, absolutePath);
+  // Don't relativize if the result goes outside cwd (different drive, symlink escape)
+  if (rel.startsWith("..")) return absolutePath;
+  // Normalize to forward slashes for diff path matching
+  return rel.replace(/\\/g, "/");
+}

package/generated/pr-github.ts

@@ -5,7 +5,7 @@
  * All functions use the `gh` CLI via the PRRuntime abstraction.
  */
 
-import type { PRRuntime, PRMetadata, PRContext, PRReviewFileComment, CommandResult } from "./pr-provider";
+import type { PRRuntime, PRMetadata, PRContext, PRReviewThread, PRThreadComment, PRReviewFileComment, CommandResult } from "./pr-provider";
 import { encodeApiFilePath } from "./pr-provider";
 
 // GitHub-specific PRRef shape (used internally)
@@ -102,6 +102,21 @@ export async function fetchGhPR(
     url: string;
   };
 
+  // Fetch the merge-base SHA — the common ancestor commit GitHub uses to compute the PR diff.
+  // baseSha (baseRefOid) is the tip of the base branch, which may have moved since the branch point.
+  // File contents must be fetched at the merge-base to match the diff hunks.
+  let mergeBaseSha: string | undefined;
+  try {
+    const compareResult = await runtime.runCommand("gh", hostnameArgs(ref.host, [
+      "api",
+      `repos/${ref.owner}/${ref.repo}/compare/${raw.baseRefOid}...${raw.headRefOid}`,
+      "--jq", ".merge_base_commit.sha",
+    ]));
+    if (compareResult.exitCode === 0 && compareResult.stdout.trim()) {
+      mergeBaseSha = compareResult.stdout.trim();
+    }
+  } catch { /* fallback to baseSha if compare API fails */ }
+
   const metadata: PRMetadata = {
     platform: "github",
     host: ref.host,
@@ -115,6 +130,7 @@ export async function fetchGhPR(
     headBranch: raw.headRefName,
     baseSha: raw.baseRefOid,
     headSha: raw.headRefOid,
+    mergeBaseSha,
     url: raw.url,
   };
 
@@ -162,7 +178,9 @@ function parseGhPRContext(raw: Record<string, unknown>): PRContext {
       state: str(r?.state),
       body: str(r?.body),
       submittedAt: str(r?.submittedAt),
+      ...(r?.url ? { url: str(r.url) } : {}),
     })),
+    reviewThreads: [],  // populated via GraphQL after initial fetch
     checks: arr(raw.statusCheckRollup).map((c: any) => ({
       name: str(c?.name),
       status: str(c?.status),
@@ -199,7 +217,87 @@ export async function fetchGhPRContext(
   }
 
   const raw = JSON.parse(result.stdout) as Record<string, unknown>;
-  return parseGhPRContext(raw);
+  const context = parseGhPRContext(raw);
+
+  // Fetch inline review threads via GraphQL (parallel-safe, non-blocking failure)
+  try {
+    context.reviewThreads = await fetchGhReviewThreads(runtime, ref);
+  } catch {
+    // GraphQL may not be available or may fail — degrade gracefully
+    context.reviewThreads = [];
+  }
+
+  return context;
+}
+
+// --- Review Threads (GraphQL) ---
+
+const REVIEW_THREADS_QUERY = `
+query($owner: String!, $repo: String!, $number: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 100) {
+        nodes {
+          id
+          isResolved
+          isOutdated
+          line
+          startLine
+          path
+          diffSide
+          comments(first: 50) {
+            nodes {
+              id
+              body
+              author { login }
+              createdAt
+              url
+              diffHunk
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+
+async function fetchGhReviewThreads(
+  runtime: PRRuntime,
+  ref: GhPRRef,
+): Promise<PRReviewThread[]> {
+  const result = await runtime.runCommand("gh", hostnameArgs(ref.host, [
+    "api", "graphql",
+    "-f", `query=${REVIEW_THREADS_QUERY}`,
+    "-f", `owner=${ref.owner}`,
+    "-f", `repo=${ref.repo}`,
+    "-F", `number=${ref.number}`,
+  ]));
+
+  if (result.exitCode !== 0) return [];
+
+  const data = JSON.parse(result.stdout);
+  const threads = data?.data?.repository?.pullRequest?.reviewThreads?.nodes;
+  if (!Array.isArray(threads)) return [];
+
+  return threads.map((t: any): PRReviewThread => ({
+    id: String(t.id ?? ''),
+    isResolved: t.isResolved === true,
+    isOutdated: t.isOutdated === true,
+    path: String(t.path ?? ''),
+    line: typeof t.line === 'number' ? t.line : null,
+    startLine: typeof t.startLine === 'number' ? t.startLine : null,
+    diffSide: t.diffSide === 'LEFT' || t.diffSide === 'RIGHT' ? t.diffSide : null,
+    comments: Array.isArray(t.comments?.nodes)
+      ? t.comments.nodes.map((c: any): PRThreadComment => ({
+          id: String(c.id ?? ''),
+          author: c.author?.login ? String(c.author.login) : '',
+          body: String(c.body ?? ''),
+          createdAt: String(c.createdAt ?? ''),
+          url: String(c.url ?? ''),
+          ...(c.diffHunk ? { diffHunk: String(c.diffHunk) } : {}),
+        }))
+      : [],
+  }));
 }
 
 // --- File Content ---

package/generated/pr-gitlab.ts

@@ -343,6 +343,7 @@ export async function fetchGlMRContext(
     mergeStateStatus,
     comments: notes,
     reviews,
+    reviewThreads: [],  // TODO: parse DiffNote positions from notes for thread support
     checks,
     linkedIssues,
   };

package/generated/pr-provider.ts

@@ -71,6 +71,8 @@ export interface GithubPRMetadata {
   headBranch: string;
   baseSha: string;
   headSha: string;
+  /** Merge-base SHA — the common ancestor commit used to compute the PR diff. Differs from baseSha when the base branch has moved. */
+  mergeBaseSha?: string;
   url: string;
 }
 
@@ -86,6 +88,8 @@ export interface GitlabMRMetadata {
   headBranch: string;
   baseSha: string;
   headSha: string;
+  /** Merge-base SHA — the common ancestor commit used to compute the MR diff. */
+  mergeBaseSha?: string;
   url: string;
 }
 
@@ -108,6 +112,7 @@ export interface PRReview {
   state: string;
   body: string;
   submittedAt: string;
+  url?: string;
 }
 
 export interface PRCheck {
@@ -124,6 +129,26 @@ export interface PRLinkedIssue {
   repo: string;
 }
 
+export interface PRThreadComment {
+  id: string;
+  author: string;
+  body: string;
+  createdAt: string;
+  url: string;
+  diffHunk?: string;
+}
+
+export interface PRReviewThread {
+  id: string;
+  isResolved: boolean;
+  isOutdated: boolean;
+  path: string;
+  line: number | null;
+  startLine: number | null;
+  diffSide: 'LEFT' | 'RIGHT' | null;
+  comments: PRThreadComment[];
+}
+
 export interface PRContext {
   body: string;
   state: string;
@@ -134,6 +159,7 @@ export interface PRContext {
   mergeStateStatus: string;
   comments: PRComment[];
   reviews: PRReview[];
+  reviewThreads: PRReviewThread[];
   checks: PRCheck[];
   linkedIssues: PRLinkedIssue[];
 }

package/generated/repo.ts

@@ -13,16 +13,24 @@ export interface RepoInfo {
  * - SSH: git@github.com:org/repo.git
  * - HTTPS: https://github.com/org/repo.git
  * - SSH with port: ssh://git@github.com:22/org/repo.git
+ * - GitLab subgroups: git@gitlab.com:group/subgroup/project.git
  */
 export function parseRemoteUrl(url: string): string | null {
 	if (!url) return null;
 
-	// SSH format: git@github.com:org/repo.git
-	const sshMatch = url.match(/:([^/]+\/[^/]+?)(?:\.git)?$/);
-	if (sshMatch) return sshMatch[1];
+	// SSH with port: ssh://git@host:22/path.git — strip scheme+host+port
+	const sshPortMatch = url.match(/^ssh:\/\/[^/]+(?::\d+)?\/(.+?)(?:\.git)?$/);
+	if (sshPortMatch) return sshPortMatch[1];
 
-	// HTTPS format: https://github.com/org/repo.git
-	const httpsMatch = url.match(/\/([^/]+\/[^/]+?)(?:\.git)?$/);
+	// SSH format: git@host:path.git — capture full path after ':'
+	// Reject URLs with :// scheme (HTTPS with non-standard ports like :8443)
+	if (!url.includes("://")) {
+		const sshMatch = url.match(/:([^/][^:]*?)(?:\.git)?$/);
+		if (sshMatch) return sshMatch[1];
+	}
+
+	// HTTPS format: https://host/path.git — capture full path after host
+	const httpsMatch = url.match(/^https?:\/\/[^/]+\/(.+?)(?:\.git)?$/);
 	if (httpsMatch) return httpsMatch[1];
 
 	return null;