nixelo 0.0.1

package/dist/lib/convex.js

@@ -0,0 +1,675 @@
+/**
+ * Convex HTTP API client for nixelo CLI.
+ *
+ * Calls the Convex deployment's HTTP action endpoints with CLI token auth.
+ */
+import { loadToken } from "./auth.js";
+export const CLI_API_PATHS = {
+    auth: "api/cli/auth",
+    tokens: "api/cli/tokens",
+    tokenRevoke: "api/cli/tokens/revoke",
+    whoami: "api/cli/whoami",
+    user: "api/cli/user",
+    usersSearch: "api/cli/users/search",
+    usersStats: "api/cli/users/stats",
+    invites: "api/cli/invites",
+    inviteResend: "api/cli/invites/resend",
+    inviteRevoke: "api/cli/invites/revoke",
+    apiKeys: "api/cli/apikeys",
+    apiKeyRevoke: "api/cli/apikeys/revoke",
+    apiKeyRotate: "api/cli/apikeys/rotate",
+    apiKeyUsage: "api/cli/apikeys/usage",
+    automations: "api/cli/automations",
+    automationRemove: "api/cli/automations/remove",
+    automationUpdate: "api/cli/automations/update",
+    documents: "api/cli/documents",
+    document: "api/cli/document",
+    documentSearch: "api/cli/documents/search",
+    documentTree: "api/cli/documents/tree",
+    customFields: "api/cli/fields",
+    time: "api/cli/time",
+    timeSummary: "api/cli/time/summary",
+    templates: "api/cli/templates",
+    statsCycleTime: "api/cli/stats/cycle-time",
+    statsOrg: "api/cli/stats/org",
+    statsProject: "api/cli/stats/project",
+    savedFilters: "api/cli/filters",
+    savedFilterFavorite: "api/cli/filters/favorite",
+    savedFilterRemove: "api/cli/filters/remove",
+    savedFilterUpdate: "api/cli/filters/update",
+    notifications: "api/cli/notifications",
+    notificationDismiss: "api/cli/notifications/dismiss",
+    issues: "api/cli/issues",
+    issuesBulkAssign: "api/cli/issues/bulk/assign",
+    issuesBulkDate: "api/cli/issues/bulk/date",
+    issuesBulkLabels: "api/cli/issues/bulk/labels",
+    issuesBulkLifecycle: "api/cli/issues/bulk/lifecycle",
+    issuesBulkPriority: "api/cli/issues/bulk/priority",
+    issuesBulkSprint: "api/cli/issues/bulk/sprint",
+    issuesBulkStatus: "api/cli/issues/bulk/status",
+    issue: "api/cli/issue",
+    issueUpdate: "api/cli/issue/update",
+    issueMove: "api/cli/issue/move",
+    issueDelete: "api/cli/issue/delete",
+    issueArchive: "api/cli/issue/archive",
+    issueRestore: "api/cli/issue/restore",
+    issueSubtasks: "api/cli/issue/subtasks",
+    issueSimilar: "api/cli/issue/similar",
+    issueComments: "api/cli/issue/comments",
+    issueComment: "api/cli/issue/comment",
+    issueActivity: "api/cli/issue/activity",
+    projects: "api/cli/projects",
+    project: "api/cli/project",
+    projectUpdate: "api/cli/project/update",
+    projectDelete: "api/cli/project/delete",
+    projectRestore: "api/cli/project/restore",
+    projectWorkflow: "api/cli/project/workflow",
+    projectWorkflowSet: "api/cli/project/workflow/set",
+    projectWorkflowReorder: "api/cli/project/workflow/reorder",
+    projectMembers: "api/cli/project/members",
+    projectMemberAdd: "api/cli/project/member/add",
+    projectMemberRemove: "api/cli/project/member/remove",
+    projectMemberRole: "api/cli/project/member/role",
+    projectStats: "api/cli/project/stats",
+    sprints: "api/cli/sprints",
+    sprint: "api/cli/sprint",
+    sprintStart: "api/cli/sprint/start",
+    sprintUpdate: "api/cli/sprint/update",
+    sprintComplete: "api/cli/sprint/complete",
+    sprintBurndown: "api/cli/sprint/burndown",
+    statsSprint: "api/cli/stats/sprint",
+    statsTeam: "api/cli/stats/team",
+    labels: "api/cli/labels",
+    labelUpdate: "api/cli/label/update",
+    labelRemove: "api/cli/label/remove",
+    teams: "api/cli/teams",
+    team: "api/cli/team",
+    teamUpdate: "api/cli/team/update",
+    teamDelete: "api/cli/team/delete",
+    teamRestore: "api/cli/team/restore",
+    teamMemberAdd: "api/cli/team/member/add",
+    teamMemberRemove: "api/cli/team/member/remove",
+    teamMemberRole: "api/cli/team/member/role",
+    workspaces: "api/cli/workspaces",
+    workspace: "api/cli/workspace",
+    workspaceUpdate: "api/cli/workspace/update",
+    workspaceArchive: "api/cli/workspace/archive",
+    workspaceDelete: "api/cli/workspace/delete",
+    workspaceMembers: "api/cli/workspace/members",
+    workspaceMemberAdd: "api/cli/workspace/member/add",
+    workspaceMemberRemove: "api/cli/workspace/member/remove",
+    workspaceMemberRole: "api/cli/workspace/member/role",
+    webhooks: "api/cli/webhooks",
+    webhookUpdate: "api/cli/webhook/update",
+    webhookDelete: "api/cli/webhook/delete",
+    webhookTest: "api/cli/webhook/test",
+    webhookExecutions: "api/cli/webhook/executions",
+    webhookRetry: "api/cli/webhook/retry"
+};
+function getConvexSiteUrl() {
+    return process.env.NIXELO_SITE_URL ?? "https://rightful-flamingo-217.convex.site";
+}
+export function buildCliApiUrl(path) {
+    return new URL(path, `${getConvexSiteUrl().replace(/\/+$/, "")}/`).toString();
+}
+async function request(method, path, body) {
+    const token = await loadToken();
+    if (!token) {
+        throw new Error("Not authenticated. Run `npx nixelo login` first.");
+    }
+    const url = buildCliApiUrl(path);
+    const response = await fetch(url, {
+        method,
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json"
+        },
+        body: body ? JSON.stringify(body) : undefined
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error("Token expired or invalid. Run `npx nixelo login` to re-authenticate.");
+        }
+        if (response.status === 403) {
+            throw new Error("Insufficient permissions for this operation.");
+        }
+        const text = await response.text();
+        throw new Error(`API error ${response.status}: ${text}`);
+    }
+    return (await response.json());
+}
+export function isCliAuthenticationError(error) {
+    return (error instanceof Error &&
+        (error.message.includes("Not authenticated") ||
+            error.message.includes("Token expired or invalid")));
+}
+export function isCliPermissionError(error) {
+    return error instanceof Error && error.message === "Insufficient permissions for this operation.";
+}
+export async function listTokens() {
+    return request("GET", CLI_API_PATHS.tokens);
+}
+export async function revokeToken(tokenId) {
+    return request("POST", CLI_API_PATHS.tokenRevoke, { tokenId });
+}
+export async function getCurrentUser() {
+    return request("GET", CLI_API_PATHS.whoami);
+}
+export async function searchUsers(query, limit) {
+    const params = new URLSearchParams({ q: query });
+    if (limit !== undefined)
+        params.set("limit", String(limit));
+    return request("GET", `${CLI_API_PATHS.usersSearch}?${params}`);
+}
+export async function getUser(reference) {
+    return request("GET", `${CLI_API_PATHS.user}?${new URLSearchParams({ ref: reference })}`);
+}
+export async function getUserStats() {
+    return request("GET", CLI_API_PATHS.usersStats);
+}
+export async function listInvites(limit) {
+    const params = new URLSearchParams();
+    if (limit !== undefined)
+        params.set("limit", String(limit));
+    const query = params.size > 0 ? `?${params}` : "";
+    return request("GET", `${CLI_API_PATHS.invites}${query}`);
+}
+export async function listApiKeys(limit) {
+    const query = limit === undefined ? "" : `?limit=${encodeURIComponent(String(limit))}`;
+    return request("GET", `${CLI_API_PATHS.apiKeys}${query}`);
+}
+export async function generateApiKey(input) {
+    return request("POST", CLI_API_PATHS.apiKeys, input);
+}
+export async function revokeApiKey(keyId) {
+    return request("POST", CLI_API_PATHS.apiKeyRevoke, { keyId });
+}
+export async function rotateApiKey(keyId) {
+    return request("POST", CLI_API_PATHS.apiKeyRotate, { keyId });
+}
+export async function getApiKeyUsage(keyId) {
+    return request("GET", `${CLI_API_PATHS.apiKeyUsage}?id=${encodeURIComponent(keyId)}`);
+}
+export async function listAutomationRules(projectKey, options = {}) {
+    const params = new URLSearchParams({ project: projectKey });
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.automations}?${params.toString()}`);
+}
+export async function createAutomationRule(input) {
+    return request("POST", CLI_API_PATHS.automations, input);
+}
+export async function updateAutomationRule(id, input) {
+    return request("POST", CLI_API_PATHS.automationUpdate, { id, ...input });
+}
+export async function removeAutomationRule(id) {
+    return request("POST", CLI_API_PATHS.automationRemove, { id });
+}
+export async function listSavedFilters(projectKey, options = {}) {
+    const params = new URLSearchParams({ project: projectKey });
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.savedFilters}?${params.toString()}`);
+}
+export async function createSavedFilter(input) {
+    return request("POST", CLI_API_PATHS.savedFilters, input);
+}
+export async function updateSavedFilter(id, input) {
+    return request("POST", CLI_API_PATHS.savedFilterUpdate, { id, ...input });
+}
+export async function removeSavedFilter(id) {
+    return request("POST", CLI_API_PATHS.savedFilterRemove, { id });
+}
+export async function toggleSavedFilterFavorite(id) {
+    return request("POST", CLI_API_PATHS.savedFilterFavorite, { id });
+}
+export async function listNotifications(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    if (options.unread !== undefined)
+        params.set("unread", String(options.unread));
+    const query = params.size > 0 ? `?${params}` : "";
+    return request("GET", `${CLI_API_PATHS.notifications}${query}`);
+}
+export async function markNotificationRead(id) {
+    return request("POST", CLI_API_PATHS.notifications, { id });
+}
+export async function dismissNotification(id) {
+    return request("POST", CLI_API_PATHS.notificationDismiss, { id });
+}
+export const CUSTOM_FIELD_TYPE_VALUES = [
+    "text",
+    "number",
+    "select",
+    "multiselect",
+    "multiemail",
+    "date",
+    "checkbox",
+    "url",
+    "user"
+];
+export async function listCustomFields(projectKey, options = {}) {
+    const params = new URLSearchParams({ project: projectKey });
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.customFields}?${params.toString()}`);
+}
+export async function createCustomField(input) {
+    return request("POST", CLI_API_PATHS.customFields, input);
+}
+export async function updateCustomField(input) {
+    return request("PATCH", CLI_API_PATHS.customFields, input);
+}
+export async function removeCustomField(id) {
+    return request("DELETE", CLI_API_PATHS.customFields, { id });
+}
+export async function startTimeEntry(input) {
+    return request("POST", CLI_API_PATHS.time, input);
+}
+export async function stopTimeEntry(id) {
+    return request("PATCH", CLI_API_PATHS.time, { id });
+}
+export async function listTimeEntries(options) {
+    const params = new URLSearchParams();
+    if (options.endDate !== undefined)
+        params.set("end", String(options.endDate));
+    if (options.issue)
+        params.set("issue", options.issue);
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    if (options.project)
+        params.set("project", options.project);
+    if (options.startDate !== undefined)
+        params.set("start", String(options.startDate));
+    return request("GET", `${CLI_API_PATHS.time}?${params.toString()}`);
+}
+export async function summarizeTimeEntries(options) {
+    const params = new URLSearchParams();
+    if (options.endDate !== undefined)
+        params.set("end", String(options.endDate));
+    if (options.project)
+        params.set("project", options.project);
+    if (options.startDate !== undefined)
+        params.set("start", String(options.startDate));
+    return request("GET", `${CLI_API_PATHS.timeSummary}?${params.toString()}`);
+}
+export const ISSUE_TEMPLATE_TYPE_VALUES = ["task", "bug", "story", "epic"];
+export const ISSUE_TEMPLATE_PRIORITY_VALUES = [
+    "lowest",
+    "low",
+    "medium",
+    "high",
+    "highest"
+];
+export async function listIssueTemplates(projectKey, options = {}) {
+    const params = new URLSearchParams({ project: projectKey });
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    if (options.type)
+        params.set("type", options.type);
+    return request("GET", `${CLI_API_PATHS.templates}?${params.toString()}`);
+}
+export async function createIssueTemplate(input) {
+    return request("POST", CLI_API_PATHS.templates, input);
+}
+export async function updateIssueTemplate(id, updates) {
+    return request("PATCH", CLI_API_PATHS.templates, { id, ...updates });
+}
+export async function removeIssueTemplate(id) {
+    return request("DELETE", CLI_API_PATHS.templates, { id });
+}
+export async function sendInvite(email, role) {
+    return request("POST", CLI_API_PATHS.invites, { email, role });
+}
+export async function revokeInvite(inviteId) {
+    return request("POST", CLI_API_PATHS.inviteRevoke, { inviteId });
+}
+export async function resendInvite(inviteId) {
+    return request("POST", CLI_API_PATHS.inviteResend, { inviteId });
+}
+export async function listIssues(options = {}) {
+    const params = new URLSearchParams();
+    if (options.project)
+        params.set("project", options.project);
+    if (options.status)
+        params.set("status", options.status);
+    if (options.priority)
+        params.set("priority", options.priority);
+    if (options.search)
+        params.set("search", options.search);
+    if (options.label)
+        params.set("label", options.label);
+    if (options.sprintId)
+        params.set("sprint", options.sprintId);
+    if (options.epic)
+        params.set("epic", options.epic);
+    if (options.type)
+        params.set("type", options.type);
+    if (options.assignee)
+        params.set("assignee", options.assignee);
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    const qs = params.toString();
+    return request("GET", `${CLI_API_PATHS.issues}${qs ? `?${qs}` : ""}`);
+}
+export async function bulkUpdateIssueStatus(keys, status) {
+    return request("POST", CLI_API_PATHS.issuesBulkStatus, { keys, status });
+}
+export async function bulkUpdateIssuePriority(keys, priority) {
+    return request("POST", CLI_API_PATHS.issuesBulkPriority, { keys, priority });
+}
+export async function bulkUpdateIssueDate(keys, field, value) {
+    return request("POST", CLI_API_PATHS.issuesBulkDate, { keys, field, value });
+}
+export async function bulkIssueLifecycle(keys, action) {
+    return request("POST", CLI_API_PATHS.issuesBulkLifecycle, { keys, action });
+}
+export async function bulkAssignIssues(keys, assignee) {
+    return request("POST", CLI_API_PATHS.issuesBulkAssign, { keys, assignee });
+}
+export async function bulkUpdateIssueLabels(keys, action, labels) {
+    return request("POST", CLI_API_PATHS.issuesBulkLabels, { keys, action, labels });
+}
+export async function bulkMoveIssuesToSprint(keys, sprint) {
+    return request("POST", CLI_API_PATHS.issuesBulkSprint, { keys, sprint });
+}
+export async function listSprints(projectKey, options = {}) {
+    const params = new URLSearchParams({ project: projectKey });
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.sprints}?${params.toString()}`);
+}
+export async function getSprint(id) {
+    return request("GET", `${CLI_API_PATHS.sprint}?id=${encodeURIComponent(id)}`);
+}
+export async function createSprint(input) {
+    return request("POST", CLI_API_PATHS.sprints, input);
+}
+export async function startSprint(id, options = {}) {
+    return request("POST", CLI_API_PATHS.sprintStart, { sprintId: id, ...options });
+}
+export async function updateSprint(id, input) {
+    return request("POST", CLI_API_PATHS.sprintUpdate, { sprintId: id, ...input });
+}
+export async function completeSprint(id, input = {}) {
+    return request("POST", CLI_API_PATHS.sprintComplete, { sprintId: id, ...input });
+}
+export async function getSprintBurndown(id) {
+    return request("GET", `${CLI_API_PATHS.sprintBurndown}?id=${encodeURIComponent(id)}`);
+}
+export async function listDocuments(options = {}) {
+    const params = new URLSearchParams();
+    if (options.workspace !== undefined)
+        params.set("workspace", options.workspace);
+    if (options.team !== undefined)
+        params.set("team", options.team);
+    if (options.project !== undefined)
+        params.set("project", options.project);
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    const query = params.size > 0 ? `?${params.toString()}` : "";
+    return request("GET", `${CLI_API_PATHS.documents}${query}`);
+}
+export async function getDocument(id) {
+    const params = new URLSearchParams({ id });
+    return request("GET", `${CLI_API_PATHS.document}?${params.toString()}`);
+}
+export async function searchDocuments(query, options = {}) {
+    const params = new URLSearchParams({ q: query });
+    if (options.workspace !== undefined)
+        params.set("workspace", options.workspace);
+    if (options.team !== undefined)
+        params.set("team", options.team);
+    if (options.project !== undefined)
+        params.set("project", options.project);
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.documentSearch}?${params.toString()}`);
+}
+export async function getDocumentTree(options = {}) {
+    const params = new URLSearchParams();
+    if (options.workspace !== undefined)
+        params.set("workspace", options.workspace);
+    if (options.team !== undefined)
+        params.set("team", options.team);
+    if (options.project !== undefined)
+        params.set("project", options.project);
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    const query = params.size > 0 ? `?${params.toString()}` : "";
+    return request("GET", `${CLI_API_PATHS.documentTree}${query}`);
+}
+export async function listProjects() {
+    return request("GET", CLI_API_PATHS.projects);
+}
+export async function getProject(key) {
+    const params = new URLSearchParams({ project: key });
+    return request("GET", `${CLI_API_PATHS.project}?${params.toString()}`);
+}
+export async function createProject(options) {
+    return request("POST", CLI_API_PATHS.projects, options);
+}
+export async function updateProject(key, options) {
+    return request("POST", CLI_API_PATHS.projectUpdate, { projectKey: key, ...options });
+}
+export async function deleteProject(key) {
+    return request("POST", CLI_API_PATHS.projectDelete, { projectKey: key });
+}
+export async function restoreProject(key) {
+    return request("POST", CLI_API_PATHS.projectRestore, { projectKey: key });
+}
+export async function listProjectWorkflow(key) {
+    const params = new URLSearchParams({ project: key });
+    return request("GET", `${CLI_API_PATHS.projectWorkflow}?${params.toString()}`);
+}
+export async function setProjectWorkflow(key, options) {
+    return request("POST", CLI_API_PATHS.projectWorkflowSet, { projectKey: key, ...options });
+}
+export async function reorderProjectWorkflow(key, options) {
+    return request("POST", CLI_API_PATHS.projectWorkflowReorder, { projectKey: key, ...options });
+}
+export async function listProjectMembers(key, options = {}) {
+    const params = new URLSearchParams({ project: key });
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.projectMembers}?${params.toString()}`);
+}
+export async function addProjectMember(options) {
+    return request("POST", CLI_API_PATHS.projectMemberAdd, options);
+}
+export async function removeProjectMember(options) {
+    return request("POST", CLI_API_PATHS.projectMemberRemove, options);
+}
+export async function updateProjectMemberRole(options) {
+    return request("POST", CLI_API_PATHS.projectMemberRole, options);
+}
+export async function getProjectStats(key) {
+    const params = new URLSearchParams({ project: key });
+    return request("GET", `${CLI_API_PATHS.projectStats}?${params.toString()}`);
+}
+export async function getStatsProject(key) {
+    const params = new URLSearchParams({ project: key });
+    return request("GET", `${CLI_API_PATHS.statsProject}?${params.toString()}`);
+}
+export async function getStatsCycleTime(projectKey, options = {}) {
+    const params = new URLSearchParams({ project: projectKey });
+    if (options.limit !== undefined)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.statsCycleTime}?${params.toString()}`);
+}
+export async function getStatsOrg() {
+    return request("GET", CLI_API_PATHS.statsOrg);
+}
+export async function getStatsSprint(id) {
+    return request("GET", `${CLI_API_PATHS.statsSprint}?id=${encodeURIComponent(id)}`);
+}
+export async function getStatsTeam(slug) {
+    const params = new URLSearchParams({ team: slug });
+    return request("GET", `${CLI_API_PATHS.statsTeam}?${params.toString()}`);
+}
+export async function listLabels(projectKey, options = {}) {
+    const params = new URLSearchParams({ project: projectKey });
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.labels}?${params.toString()}`);
+}
+export async function createLabel(options) {
+    return request("POST", CLI_API_PATHS.labels, options);
+}
+export async function updateLabel(id, options) {
+    return request("POST", CLI_API_PATHS.labelUpdate, { id, ...options });
+}
+export async function removeLabel(id) {
+    return request("POST", CLI_API_PATHS.labelRemove, { id });
+}
+export async function listTeams(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    const qs = params.toString();
+    return request("GET", `${CLI_API_PATHS.teams}${qs ? `?${qs}` : ""}`);
+}
+export async function getTeam(slug, options = {}) {
+    const params = new URLSearchParams({ slug });
+    if (options.memberLimit)
+        params.set("limit", String(options.memberLimit));
+    return request("GET", `${CLI_API_PATHS.team}?${params.toString()}`);
+}
+export async function createTeam(options) {
+    return request("POST", CLI_API_PATHS.teams, options);
+}
+export async function updateTeam(slug, options) {
+    return request("POST", CLI_API_PATHS.teamUpdate, { slug, ...options });
+}
+export async function deleteTeam(slug) {
+    return request("POST", CLI_API_PATHS.teamDelete, { slug });
+}
+export async function restoreTeam(slug) {
+    return request("POST", CLI_API_PATHS.teamRestore, { slug });
+}
+export async function addTeamMember(options) {
+    return request("POST", CLI_API_PATHS.teamMemberAdd, options);
+}
+export async function removeTeamMember(options) {
+    return request("POST", CLI_API_PATHS.teamMemberRemove, options);
+}
+export async function updateTeamMemberRole(options) {
+    return request("POST", CLI_API_PATHS.teamMemberRole, options);
+}
+export async function listWorkspaces(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    const qs = params.toString();
+    return request("GET", `${CLI_API_PATHS.workspaces}${qs ? `?${qs}` : ""}`);
+}
+export async function getWorkspace(slug, options = {}) {
+    const params = new URLSearchParams({ slug });
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.workspace}?${params.toString()}`);
+}
+export async function createWorkspace(options) {
+    return request("POST", CLI_API_PATHS.workspaces, options);
+}
+export async function updateWorkspace(slug, options) {
+    return request("POST", CLI_API_PATHS.workspaceUpdate, { slug, ...options });
+}
+export async function archiveWorkspace(slug) {
+    return request("POST", CLI_API_PATHS.workspaceArchive, { slug });
+}
+export async function deleteWorkspace(slug) {
+    return request("POST", CLI_API_PATHS.workspaceDelete, { slug });
+}
+export async function listWorkspaceMembers(slug, options = {}) {
+    const params = new URLSearchParams({ slug });
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.workspaceMembers}?${params.toString()}`);
+}
+export async function addWorkspaceMember(options) {
+    return request("POST", CLI_API_PATHS.workspaceMemberAdd, options);
+}
+export async function removeWorkspaceMember(options) {
+    return request("POST", CLI_API_PATHS.workspaceMemberRemove, options);
+}
+export async function updateWorkspaceMemberRole(options) {
+    return request("POST", CLI_API_PATHS.workspaceMemberRole, options);
+}
+export async function listWebhooks(projectKey, options = {}) {
+    const params = new URLSearchParams({ project: projectKey });
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.webhooks}?${params.toString()}`);
+}
+export async function createWebhook(options) {
+    return request("POST", CLI_API_PATHS.webhooks, options);
+}
+export async function updateWebhook(id, options) {
+    return request("POST", CLI_API_PATHS.webhookUpdate, { id, ...options });
+}
+export async function deleteWebhook(id) {
+    return request("POST", CLI_API_PATHS.webhookDelete, { id });
+}
+export async function testWebhook(id) {
+    return request("POST", CLI_API_PATHS.webhookTest, { id });
+}
+export async function listWebhookExecutions(id, options = {}) {
+    const params = new URLSearchParams({ id });
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.webhookExecutions}?${params.toString()}`);
+}
+export async function retryWebhookExecution(id) {
+    return request("POST", CLI_API_PATHS.webhookRetry, { id });
+}
+export async function createIssue(options) {
+    return request("POST", CLI_API_PATHS.issues, options);
+}
+export async function getIssue(key) {
+    return request("GET", `${CLI_API_PATHS.issue}?key=${encodeURIComponent(key)}`);
+}
+export async function updateIssue(key, options) {
+    return request("POST", CLI_API_PATHS.issueUpdate, { key, ...options });
+}
+export async function moveIssue(key, options) {
+    return request("POST", CLI_API_PATHS.issueMove, { key, ...options });
+}
+export async function deleteIssue(key) {
+    return request("POST", CLI_API_PATHS.issueDelete, { key });
+}
+export async function archiveIssue(key) {
+    return request("POST", CLI_API_PATHS.issueArchive, { key });
+}
+export async function restoreIssue(key) {
+    return request("POST", CLI_API_PATHS.issueRestore, { key });
+}
+export async function listIssueSubtasks(key, options = {}) {
+    const params = new URLSearchParams({ key });
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.issueSubtasks}?${params.toString()}`);
+}
+export async function listSimilarIssues(key, options = {}) {
+    const params = new URLSearchParams({ key });
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.issueSimilar}?${params.toString()}`);
+}
+export async function listIssueComments(key, options = {}) {
+    const params = new URLSearchParams({ key });
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.issueComments}?${params.toString()}`);
+}
+export async function addIssueComment(key, body) {
+    return request("POST", CLI_API_PATHS.issueComment, { key, body });
+}
+export async function listIssueActivity(key, options = {}) {
+    const params = new URLSearchParams({ key });
+    if (options.limit)
+        params.set("limit", String(options.limit));
+    return request("GET", `${CLI_API_PATHS.issueActivity}?${params.toString()}`);
+}
+//# sourceMappingURL=convex.js.map