lagora-cli 1.1.0

package/dist/scripts/issue.js

@@ -0,0 +1,386 @@
+import {
+  addBlockerToStore,
+  assignIssueInStore,
+  checkoutIssueFromStore,
+  fetchIssueFromStore,
+  saveSuggestionToStore,
+  syncBlockerInStore,
+  updateIssueDescriptionInStore,
+  updateIssueStatusInStore
+} from "./chunk-NCJMUBTG.js";
+import {
+  LagoraCliConfigStore,
+  apiSession,
+  baseApiUrl,
+  readJsonFromApi,
+  writeJsonToApi
+} from "./chunk-AZ3EEBVD.js";
+import "./chunk-TJZVQYBL.js";
+
+// scripts/issue.ts
+import path2 from "node:path";
+
+// scripts/issue-api-client.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+async function fetchIssueFromApi(issueId, session, format) {
+  const endpoint = `${baseApiUrl(session.apiUrl)}/api/issues/${encodeURIComponent(issueId)}/bundle`;
+  const bundle = await readBundleFromApi(endpoint, session);
+  const issueFile = bundle.files.find((file) => file.path === "issue.json");
+  if (!issueFile) throw new Error("Issue bundle response is missing issue.json");
+  const parsed = JSON.parse(Buffer.from(issueFile.contentBase64, "base64").toString("utf8"));
+  if (!isIssueRecord(parsed)) throw new Error("Issue bundle contains an unsupported issue.json shape");
+  const { printIssueRecord } = await import("./issue-local-client-DZUXZOKY.js");
+  printIssueRecord(parsed, format);
+}
+function isIssueRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const issue = Reflect.get(value, "issue");
+  return Boolean(issue) && typeof issue === "object" && !Array.isArray(issue) && Array.isArray(Reflect.get(value, "artifacts")) && Array.isArray(Reflect.get(value, "verificationRuns")) && Boolean(Reflect.get(value, "bundle"));
+}
+async function checkoutIssueFromApi(issueId, apiUrl, out, author, session) {
+  const targetRoot = path.resolve(out?.trim() || path.join("lagora-issues", issueId));
+  const endpoint = `${baseApiUrl(apiUrl)}/api/issues/${encodeURIComponent(issueId)}/bundle`;
+  const initialPayload = await readBundleFromApi(endpoint, session);
+  const payload = initialPayload.status === "open" ? await markInvestigatingThenReadBundle({ issueId, apiUrl, author, bundleEndpoint: endpoint, session }) : initialPayload;
+  await mkdir(targetRoot, { recursive: true });
+  for (const file of payload.files) {
+    const filePath = safeOutputPath(targetRoot, file.path);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, Buffer.from(file.contentBase64, "base64"));
+  }
+  console.log(`Issue ${payload.issueId} checked out to ${targetRoot}`);
+}
+async function markInvestigatingThenReadBundle(input) {
+  await updateStatusFromApi({
+    issueId: input.issueId,
+    apiUrl: input.apiUrl,
+    author: input.author,
+    status: "investigating",
+    session: input.session
+  });
+  return await readBundleFromApi(input.bundleEndpoint, input.session);
+}
+async function addCommentFromApi(input) {
+  await writeJsonToApi(`${baseApiUrl(input.apiUrl)}/api/issues/${encodeURIComponent(input.issueId)}/comments`, "POST", {
+    author: input.author,
+    body: input.body,
+    kind: input.kind
+  }, input.session);
+  console.log(`Comment added to ${input.issueId}`);
+}
+async function updateStatusFromApi(input) {
+  await writeJsonToApi(`${baseApiUrl(input.apiUrl)}/api/issues/${encodeURIComponent(input.issueId)}/status`, "PATCH", {
+    author: input.author,
+    status: input.status
+  }, input.session);
+  console.log(`Status updated: ${input.issueId} -> ${input.status}`);
+}
+async function updateDescriptionFromApi(input) {
+  await writeJsonToApi(`${baseApiUrl(input.apiUrl)}/api/issues/${encodeURIComponent(input.issueId)}/description`, "PATCH", {
+    author: input.author,
+    description: input.description
+  }, input.session);
+  console.log(`Description updated for ${input.issueId}`);
+}
+async function saveSuggestionFromApi(input) {
+  await writeJsonToApi(`${baseApiUrl(input.apiUrl)}/api/issues/${encodeURIComponent(input.issueId)}/suggestions`, "POST", {
+    author: input.author,
+    filename: input.filename,
+    content: input.content,
+    baseArtifactId: input.baseArtifactId ?? "",
+    suggestionArtifactId: input.suggestionArtifactId ?? ""
+  }, input.session);
+  console.log(`${input.suggestionArtifactId ? "Suggestion updated" : "Suggestion added"} for ${input.issueId}`);
+}
+async function assignIssueFromApi(input) {
+  await writeJsonToApi(`${baseApiUrl(input.apiUrl)}/api/issues/${encodeURIComponent(input.issueId)}/assignee`, "PATCH", {
+    author: input.author,
+    assignee: input.assignee
+  }, input.session);
+  console.log(`Assignee updated: ${input.issueId} -> ${input.assignee || "unassigned"}`);
+}
+async function addBlockerFromApi(input) {
+  const payload = await writeJsonToApi(`${baseApiUrl(input.apiUrl)}/api/issues/${encodeURIComponent(input.issueId)}/blockers`, "POST", {
+    author: input.author,
+    repository: input.repository ?? "",
+    number: String(input.number)
+  }, input.session);
+  const blocker = readBlocker(payload);
+  console.log(`Blocker linked: ${input.issueId} -> ${blocker.repository}#${blocker.number} (${blocker.status})`);
+}
+async function syncBlockerFromApi(input) {
+  const payload = await writeJsonToApi(`${baseApiUrl(input.apiUrl)}/api/issues/${encodeURIComponent(input.issueId)}/blockers`, "PATCH", {
+    author: input.author,
+    blockerId: input.blockerId
+  }, input.session);
+  const blocker = readBlocker(payload);
+  console.log(`Blocker synced: ${input.issueId} -> ${blocker.repository}#${blocker.number} (${blocker.status})`);
+}
+async function readBundleFromApi(endpoint, session) {
+  const payload = await readJsonFromApi(endpoint, session);
+  if (!isApiBundle(payload)) {
+    throw new Error("Issue bundle response has an unsupported shape");
+  }
+  return payload;
+}
+function isApiBundle(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const issueId = Reflect.get(value, "issueId");
+  const title = Reflect.get(value, "title");
+  const status = Reflect.get(value, "status");
+  const files = Reflect.get(value, "files");
+  return typeof issueId === "string" && typeof title === "string" && isIssueStatus(status) && Array.isArray(files) && files.every(isApiBundleFile);
+}
+function isIssueStatus(value) {
+  return value === "open" || value === "investigating" || value === "resolved" || value === "deferred" || value === "cancelled";
+}
+function isApiBundleFile(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  return typeof Reflect.get(value, "path") === "string" && typeof Reflect.get(value, "contentType") === "string" && typeof Reflect.get(value, "contentBase64") === "string";
+}
+function readBlocker(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error("Blocker response has an unsupported shape");
+  }
+  const blocker = Reflect.get(payload, "blocker");
+  if (!isIssueBlocker(blocker)) {
+    throw new Error("Blocker response has an unsupported shape");
+  }
+  return blocker;
+}
+function isIssueBlocker(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return typeof Reflect.get(value, "id") === "string" && Reflect.get(value, "kind") === "github-pr" && typeof Reflect.get(value, "repository") === "string" && typeof Reflect.get(value, "number") === "number" && typeof Reflect.get(value, "url") === "string" && isBlockerStatus(Reflect.get(value, "status")) && typeof Reflect.get(value, "addedBy") === "string" && typeof Reflect.get(value, "addedAt") === "string";
+}
+function isBlockerStatus(value) {
+  return value === "open" || value === "merged" || value === "closed" || value === "unknown";
+}
+function safeOutputPath(root, relativePath) {
+  if (path.isAbsolute(relativePath)) {
+    throw new Error(`Absolute bundle path is not allowed: ${relativePath}`);
+  }
+  const target = path.resolve(root, relativePath);
+  if (target !== root && !target.startsWith(`${root}${path.sep}`)) {
+    throw new Error(`Bundle path escapes output directory: ${relativePath}`);
+  }
+  return target;
+}
+
+// scripts/issue-api-notifications.ts
+async function listNotificationsFromApi(session) {
+  return parseNotificationPayload(await readJsonFromApi(`${baseApiUrl(session.apiUrl)}/api/user/notifications`, session));
+}
+async function markNotificationReadFromApi(session, notificationId) {
+  return parseNotificationPayload(await writeJsonToApi(`${baseApiUrl(session.apiUrl)}/api/user/notifications`, "PATCH", { notificationId }, session));
+}
+async function markAllNotificationsReadFromApi(session) {
+  return parseNotificationPayload(await writeJsonToApi(`${baseApiUrl(session.apiUrl)}/api/user/notifications`, "PATCH", { markAll: true }, session));
+}
+function formatNotifications(payload) {
+  if (payload.notifications.length === 0) return "No notifications.";
+  const lines = [`Unread: ${payload.unreadCount}`];
+  for (const notification of payload.notifications) {
+    const state = notification.readAt ? "read" : "unread";
+    lines.push([
+      `[${state}] ${notification.id}`,
+      `${notification.eventType}: ${notification.title}`,
+      notification.body,
+      notification.linkUrl ? `link: ${notification.linkUrl}` : "",
+      `created: ${notification.createdAt}`
+    ].filter(Boolean).join("\n  "));
+  }
+  return lines.join("\n\n");
+}
+function parseNotificationPayload(payload) {
+  if (!isNotificationPayload(payload)) throw new Error("Notification response has an unsupported shape");
+  return payload;
+}
+function isNotificationPayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const notifications = Reflect.get(value, "notifications");
+  const unreadCount = Reflect.get(value, "unreadCount");
+  const userId = Reflect.get(value, "userId");
+  return typeof userId === "string" && Array.isArray(notifications) && typeof unreadCount === "number" && notifications.every(isNotificationItem);
+}
+function isNotificationItem(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return typeof Reflect.get(value, "id") === "string" && typeof Reflect.get(value, "eventType") === "string" && typeof Reflect.get(value, "title") === "string" && typeof Reflect.get(value, "body") === "string" && (Reflect.get(value, "linkUrl") === void 0 || typeof Reflect.get(value, "linkUrl") === "string") && (Reflect.get(value, "readAt") === void 0 || typeof Reflect.get(value, "readAt") === "string") && typeof Reflect.get(value, "createdAt") === "string";
+}
+
+// scripts/issue.ts
+function parseArgs(argv) {
+  const args = { command: argv[0], subcommand: argv[1]?.startsWith("--") ? void 0 : argv[1] };
+  const optionStart = args.subcommand ? 2 : 1;
+  for (let index = optionStart; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    const value = argv[index + 1];
+    if (!token.startsWith("--")) continue;
+    if (token === "--unassign") {
+      args.unassign = true;
+      continue;
+    }
+    if (!value || value.startsWith("--")) throw new Error(`${token} requires a value`);
+    index += 1;
+    setOption(args, token, value);
+  }
+  if (args.unassign && args.command !== "assign") throw new Error("--unassign is only valid with assign");
+  return args;
+}
+function setOption(args, token, value) {
+  switch (token) {
+    case "--issue":
+      args.issue = value;
+      return;
+    case "--author":
+      args.author = value;
+      return;
+    case "--notification":
+      args.notification = value;
+      return;
+    case "--body":
+      args.body = value;
+      return;
+    case "--kind":
+      args.kind = value;
+      return;
+    case "--status":
+      args.status = value;
+      return;
+    case "--assignee":
+      args.assignee = value;
+      return;
+    case "--repo":
+    case "--repository":
+      args.repository = value;
+      return;
+    case "--pr":
+    case "--number":
+      args.number = value;
+      return;
+    case "--blocker-id":
+      args.blockerId = value;
+      return;
+    case "--file":
+      args.file = value;
+      return;
+    case "--filename":
+      args.filename = value;
+      return;
+    case "--base-artifact":
+      args.baseArtifactId = value;
+      return;
+    case "--suggestion-id":
+      args.suggestionArtifactId = value;
+      return;
+    case "--format":
+      args.format = value;
+      return;
+    case "--out":
+      args.out = value;
+      return;
+    case "--store":
+      args.store = value;
+      return;
+    case "--api-url":
+      args.apiUrl = value;
+      return;
+    default:
+      throw new Error(`Unknown option: ${token}`);
+  }
+}
+function requireArg(value, name) {
+  if (!value?.trim()) throw new Error(`${name} is required`);
+  return value.trim();
+}
+function assertCommentKind(kind) {
+  if (kind === "analysis" || kind === "solution") return kind;
+  return "comment";
+}
+function assertStatus(status) {
+  const value = requireArg(status, "--status");
+  if (value === "open" || value === "investigating" || value === "resolved" || value === "deferred" || value === "cancelled") return value;
+  throw new Error(`Unsupported status: ${value}`);
+}
+function assignmentValue(args) {
+  if (args.unassign && args.assignee !== void 0) throw new Error("Use either --assignee <name> or --unassign, not both");
+  return args.unassign ? "" : requireArg(args.assignee, "--assignee");
+}
+async function apiContext(args, store) {
+  const session = await store.apiSession(args.apiUrl);
+  return apiSession(session.apiUrl, { cookie: session.cookie, token: session.token });
+}
+async function notificationCommand(args, store) {
+  const session = await apiContext(args, store);
+  if (!session.token && !session.cookie) throw new Error("Run `lagora login` first");
+  if (args.subcommand === "read") {
+    console.log(formatNotifications(await markNotificationReadFromApi(session, requireArg(args.notification, "--notification"))));
+    return;
+  }
+  if (args.subcommand === "read-all") {
+    console.log(formatNotifications(await markAllNotificationsReadFromApi(session)));
+    return;
+  }
+  const payload = await listNotificationsFromApi(session);
+  console.log(args.format === "json" ? JSON.stringify(payload, null, 2) : formatNotifications(payload));
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const store = new LagoraCliConfigStore();
+  if (args.store?.trim()) process.env.AGORA_ISSUE_STORE = path2.resolve(args.store.trim());
+  if (args.command === "login" || args.command === "logout" || args.command === "whoami") {
+    throw new Error(`Use \`lagora ${args.command}\` instead`);
+  }
+  if (args.command === "notifications") return notificationCommand(args, store);
+  const issueId = requireArg(args.issue, "--issue");
+  const author = await store.author(args.author);
+  const storedSession = args.store?.trim() ? void 0 : await store.apiSession(args.apiUrl);
+  const session = storedSession ? apiSession(storedSession.apiUrl, { cookie: storedSession.cookie, token: storedSession.token }) : void 0;
+  if (args.command === "fetch") return session ? fetchIssueFromApi(issueId, session, args.format) : fetchIssueFromStore(issueId, args.format);
+  if (args.command === "checkout") return session ? checkoutIssueFromApi(issueId, session.apiUrl, args.out, author, session) : checkoutIssueFromStore(issueId, args.out, author);
+  if (args.command === "comment") return session ? addCommentFromApi({ issueId, apiUrl: session.apiUrl, author, body: requireArg(args.body, "--body"), kind: assertCommentKind(args.kind), session }) : addLocalComment(issueId, author, requireArg(args.body, "--body"), assertCommentKind(args.kind));
+  if (args.command === "status") return session ? updateStatusFromApi({ issueId, apiUrl: session.apiUrl, author, status: assertStatus(args.status), session }) : updateIssueStatusInStore(issueId, assertStatus(args.status), author);
+  if (args.command === "description") return session ? updateDescriptionFromApi({ issueId, apiUrl: session.apiUrl, author, description: requireArg(args.body, "--body"), session }) : updateIssueDescriptionInStore(issueId, requireArg(args.body, "--body"), author);
+  if (args.command === "suggestion") return session ? saveSuggestionFromApi({
+    issueId,
+    apiUrl: session.apiUrl,
+    author,
+    filename: args.filename?.trim() || path2.basename(requireArg(args.file, "--file")),
+    content: await readSuggestionFile(args.file),
+    baseArtifactId: args.baseArtifactId?.trim(),
+    suggestionArtifactId: args.suggestionArtifactId?.trim(),
+    session
+  }) : saveSuggestionToStore({ issueId, file: requireArg(args.file, "--file"), filename: args.filename, baseArtifactId: args.baseArtifactId, suggestionArtifactId: args.suggestionArtifactId, author });
+  if (args.command === "assign") {
+    const assignee = assignmentValue(args);
+    return session ? assignIssueFromApi({ issueId, apiUrl: session.apiUrl, author, assignee, session }) : assignIssueInStore({ issueId, assignee, author });
+  }
+  if (args.command === "blocker") return blockerCommand(args, issueId, author, session);
+  throw new Error("Usage: lagora issue notifications|fetch|checkout|comment|status|suggestion|assign|blocker --issue <id> [--api-url url] [--store path]; assign requires --assignee <name> or --unassign");
+}
+async function addLocalComment(issueId, author, body, kind) {
+  const { addComment } = await import("./storage-234FBH54.js");
+  await addComment({ issueId, author, body, kind });
+  console.log(`Comment added to ${issueId}`);
+}
+async function readSuggestionFile(file) {
+  const { readFile } = await import("node:fs/promises");
+  return readFile(path2.resolve(requireArg(file, "--file")), "utf8");
+}
+async function blockerCommand(args, issueId, author, session) {
+  if (args.subcommand === "sync") {
+    const blockerId = requireArg(args.blockerId, "--blocker-id");
+    return session ? syncBlockerFromApi({ issueId, apiUrl: session.apiUrl, author, blockerId, session }) : syncBlockerInStore({ issueId, blockerId, author });
+  }
+  const number = Number.parseInt(requireArg(args.number, "--pr"), 10);
+  if (!Number.isInteger(number) || number <= 0) throw new Error(`Unsupported pull request number: ${args.number}`);
+  return session ? addBlockerFromApi({ issueId, apiUrl: session.apiUrl, author, repository: args.repository?.trim(), number, session }) : addBlockerToStore({ issueId, repository: args.repository?.trim(), number, author });
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});