runline 0.12.0 → 0.14.0

package/dist/plugins/shiftLabs/src/issue-views.js

@@ -0,0 +1,179 @@
+import * as t from "typebox";
+import { enumSchema, ISSUE_PRIORITY, ISSUE_STATUS, ISSUE_VIEW_GROUP, ISSUE_VIEW_LAYOUT, ISSUE_VIEW_SORT, ISSUE_VIEW_VISIBILITY, pathSegment, request, } from "./shared.js";
+const viewFields = {
+    name: t.String({ minLength: 1, maxLength: 120, description: "View name" }),
+    visibility: t.Optional(t.Literal("organization")),
+    layout: t.Optional(enumSchema("View layout", ISSUE_VIEW_LAYOUT)),
+    projectId: t.Optional(t.String({ minLength: 1 })),
+    rootIssueId: t.Optional(t.String({ minLength: 1 })),
+    statuses: t.Optional(t.Array(enumSchema("Issue status", ISSUE_STATUS), { maxItems: 5 })),
+    priorities: t.Optional(t.Array(enumSchema("Issue priority", ISSUE_PRIORITY), { maxItems: 5 })),
+    assigneeUserIds: t.Optional(t.Array(t.String({ minLength: 1 }), { maxItems: 20 })),
+    labels: t.Optional(t.Array(t.String({ minLength: 1, maxLength: 64 }), { maxItems: 20 })),
+    startAfter: t.Optional(t.String()),
+    dueBefore: t.Optional(t.String()),
+    blocked: t.Optional(t.Boolean()),
+    groupBy: t.Optional(enumSchema("View grouping", ISSUE_VIEW_GROUP)),
+    sortBy: t.Optional(t.Array(enumSchema("View sort", ISSUE_VIEW_SORT), {
+        minItems: 1,
+        maxItems: 3,
+    })),
+};
+export function registerIssueViewActions(rl) {
+    const listFields = {
+        visibility: t.Optional(enumSchema("View visibility", ISSUE_VIEW_VISIBILITY)),
+        cursor: t.Optional(t.String({ minLength: 1, description: "Next-page cursor" })),
+        limit: t.Optional(t.Integer({ minimum: 1, maximum: 100 })),
+    };
+    rl.registerAction("issueView.list", {
+        access: "read",
+        description: "List the first page of personal and organization Issue Views.",
+        inputSchema: t.Object(listFields),
+        async execute(input, ctx) {
+            const body = await request(ctx, `/v1/issue-views?${listParams(input)}`);
+            return body.views;
+        },
+    });
+    rl.registerAction("issueView.listPage", {
+        access: "read",
+        description: "List a cursor-paginated page of Issue Views.",
+        inputSchema: t.Object(listFields),
+        async execute(input, ctx) {
+            return request(ctx, `/v1/issue-views?${listParams(input)}`);
+        },
+    });
+    rl.registerAction("issueView.get", {
+        access: "read",
+        description: "Get an Issue View by ID.",
+        inputSchema: t.Object({ id: t.String() }),
+        async execute(input, ctx) {
+            const { id } = input;
+            const body = await request(ctx, `/v1/issue-views/${pathSegment(id)}`);
+            return body.view;
+        },
+    });
+    rl.registerAction("issueView.issues", {
+        access: "read",
+        description: "Execute the first page of a saved Issue View.",
+        inputSchema: t.Object({
+            id: t.String({ minLength: 1 }),
+            limit: t.Optional(t.Integer({ minimum: 1, maximum: 100 })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...pagination } = input;
+            const body = await request(ctx, withQuery(`/v1/issue-views/${pathSegment(id)}/issues`, listParams(pagination)));
+            return body.issues;
+        },
+    });
+    rl.registerAction("issueView.issuesPage", {
+        access: "read",
+        description: "Execute a cursor-paginated page of a saved Issue View.",
+        inputSchema: t.Object({
+            id: t.String({ minLength: 1 }),
+            cursor: t.Optional(t.String({ minLength: 1 })),
+            limit: t.Optional(t.Integer({ minimum: 1, maximum: 100 })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...pagination } = input;
+            return request(ctx, withQuery(`/v1/issue-views/${pathSegment(id)}/issues`, listParams(pagination)));
+        },
+    });
+    rl.registerAction("issueView.create", {
+        access: "write",
+        description: "Create a bounded saved Issue query. Views never own Issue membership.",
+        inputSchema: t.Object(viewFields),
+        async execute(input, ctx) {
+            const body = await request(ctx, "/v1/issue-views", {
+                method: "POST",
+                body: JSON.stringify(toViewBody(input)),
+            });
+            return body.view;
+        },
+    });
+    rl.registerAction("issueView.update", {
+        access: "write",
+        description: "Patch a saved Issue View. Null filter values remove that filter without replacing unrelated filters.",
+        inputSchema: t.Object({
+            id: t.String({ minLength: 1 }),
+            name: t.Optional(t.String({ minLength: 1, maxLength: 120 })),
+            visibility: t.Optional(t.Literal("organization")),
+            layout: t.Optional(enumSchema("View layout", ISSUE_VIEW_LAYOUT)),
+            projectId: optionalNullableString(),
+            rootIssueId: optionalNullableString(),
+            statuses: optionalNullableArray(enumSchema("Issue status", ISSUE_STATUS), 5),
+            priorities: optionalNullableArray(enumSchema("Issue priority", ISSUE_PRIORITY), 5),
+            assigneeUserIds: optionalNullableArray(t.String({ minLength: 1 }), 20),
+            labels: optionalNullableArray(t.String({ minLength: 1, maxLength: 64 }), 20),
+            startAfter: optionalNullableString(),
+            dueBefore: optionalNullableString(),
+            blocked: t.Optional(t.Union([t.Boolean(), t.Null()])),
+            groupBy: t.Optional(t.Union([enumSchema("View grouping", ISSUE_VIEW_GROUP), t.Null()])),
+            sortBy: t.Optional(t.Array(enumSchema("View sort", ISSUE_VIEW_SORT), {
+                minItems: 1,
+                maxItems: 3,
+            })),
+        }, { minProperties: 2 }),
+        async execute(input, ctx) {
+            const { id, ...fields } = input;
+            const body = await request(ctx, `/v1/issue-views/${pathSegment(id)}`, { method: "PATCH", body: JSON.stringify(toViewBody(fields, false)) });
+            return body.view;
+        },
+    });
+    rl.registerAction("issueView.delete", {
+        access: "write",
+        description: "Delete a saved Issue View without changing any Issues.",
+        inputSchema: t.Object({ id: t.String() }),
+        async execute(input, ctx) {
+            const { id } = input;
+            await request(ctx, `/v1/issue-views/${pathSegment(id)}`, {
+                method: "DELETE",
+            });
+            return { deleted: true };
+        },
+    });
+}
+function listParams(input) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries((input ?? {}))) {
+        if (value !== undefined)
+            params.set(key, String(value));
+    }
+    return params;
+}
+function withQuery(path, params) {
+    const query = params.toString();
+    return query ? `${path}?${query}` : path;
+}
+function optionalNullableString() {
+    return t.Optional(t.Union([t.String({ minLength: 1 }), t.Null()]));
+}
+function optionalNullableArray(item, maxItems) {
+    return t.Optional(t.Union([t.Array(item, { maxItems }), t.Null()]));
+}
+function toViewBody(input, applyDefaults = true) {
+    const { projectId, rootIssueId, statuses, priorities, assigneeUserIds, labels, startAfter, dueBefore, blocked, ...view } = input;
+    const filters = Object.fromEntries(Object.entries({
+        projectId,
+        rootIssueId,
+        statuses,
+        priorities,
+        assigneeUserIds,
+        labels,
+        startAfter,
+        dueBefore,
+        blocked,
+    }).filter(([, value]) => value !== undefined));
+    return {
+        ...view,
+        ...(applyDefaults
+            ? {
+                visibility: view.visibility ?? "organization",
+                layout: view.layout ?? "list",
+            }
+            : {}),
+        ...(Object.keys(filters).length > 0 ? { filters } : {}),
+        ...(applyDefaults && view.sortBy === undefined
+            ? { sortBy: ["updatedAt"] }
+            : {}),
+    };
+}

package/dist/plugins/shiftLabs/src/issues.js

@@ -1,54 +1,86 @@
 import * as t from "typebox";
-import { enumSchema, ISSUE_KIND, ISSUE_PRIORITY, ISSUE_SEVERITY, ISSUE_SOURCE, ISSUE_STATUS, request, } from "./shared.js";
+import { enumSchema, ISSUE_PRIORITY, ISSUE_SOURCE, ISSUE_STATUS, pathSegment, request, } from "./shared.js";
+const issueListFields = {
+    status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
+    projectId: t.Optional(t.String({ minLength: 1 })),
+    parentIssueId: t.Optional(t.String({ minLength: 1 })),
+    assigneeUserId: t.Optional(t.String({ minLength: 1 })),
+    source: t.Optional(enumSchema("Issue source", ISSUE_SOURCE)),
+    cursor: t.Optional(t.String({ minLength: 1, description: "Next-page cursor" })),
+    limit: t.Optional(t.Integer({
+        minimum: 1,
+        maximum: 100,
+        description: "Max results, default 50",
+    })),
+};
+function issueListParams(input) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries((input ?? {}))) {
+        if (value !== undefined)
+            params.set(key, String(value));
+    }
+    return params;
+}
+function withQuery(path, params) {
+    const query = params.toString();
+    return query ? `${path}?${query}` : path;
+}
 export function registerIssueActions(rl) {
     rl.registerAction("issue.list", {
         access: "read",
-        description: "List Shift Labs issues for the API key's organization.",
-        inputSchema: t.Object({
-            status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
-            assigneeUserId: t.Optional(t.String()),
-            source: t.Optional(enumSchema("Issue source", ISSUE_SOURCE)),
-            limit: t.Optional(t.Number({ description: "Max results, default 50" })),
-        }),
+        description: "List the first page of Shift Labs Issues for the API key's organization.",
+        inputSchema: t.Object(issueListFields),
         async execute(input, ctx) {
-            const fields = (input ?? {});
-            const params = new URLSearchParams();
-            for (const key of ["status", "assigneeUserId", "source", "limit"]) {
-                const value = fields[key];
-                if (value !== undefined)
-                    params.set(key, String(value));
-            }
-            const body = await request(ctx, `/v1/issues?${params}`);
+            const body = await request(ctx, `/v1/issues?${issueListParams(input)}`);
             return body.issues;
         },
     });
+    rl.registerAction("issue.listPage", {
+        access: "read",
+        description: "List a cursor-paginated page of Shift Labs Issues.",
+        inputSchema: t.Object(issueListFields),
+        async execute(input, ctx) {
+            return request(ctx, `/v1/issues?${issueListParams(input)}`);
+        },
+    });
     rl.registerAction("issue.get", {
         access: "read",
-        description: "Get a Shift Labs issue by ID.",
-        inputSchema: t.Object({ id: t.String({ description: "Issue ID" }) }),
+        description: "Get a Shift Labs Issue by ID.",
+        inputSchema: t.Object({
+            id: t.String({ minLength: 1, description: "Issue ID" }),
+        }),
         async execute(input, ctx) {
             const { id } = input;
-            const body = await request(ctx, `/v1/issues/${encodeURIComponent(id)}`);
+            const body = await request(ctx, `/v1/issues/${pathSegment(id)}`);
             return body.issue;
         },
     });
     rl.registerAction("issue.create", {
         access: "write",
-        description: "Create a Shift Labs issue. The issue starts in triage.",
+        description: "Create an Issue. Leave projectId empty for inbox work; parentIssueId requires a Project.",
         inputSchema: t.Object({
-            title: t.String({ description: "Issue title" }),
-            description: t.Optional(t.String({ description: "Issue description" })),
-            kind: t.Optional(enumSchema("Issue kind", ISSUE_KIND)),
+            title: t.String({
+                minLength: 1,
+                maxLength: 160,
+                description: "Issue title",
+            }),
+            description: t.Optional(t.String({ maxLength: 20_000, description: "Issue description" })),
+            projectId: t.Optional(t.String({ minLength: 1 })),
+            parentIssueId: t.Optional(t.String({ minLength: 1 })),
+            sortOrder: t.Optional(t.Integer({ minimum: 0 })),
+            status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
             priority: t.Optional(enumSchema("Issue priority", ISSUE_PRIORITY)),
-            severity: t.Optional(enumSchema("Issue severity", ISSUE_SEVERITY)),
             source: t.Optional(enumSchema("Issue source", ISSUE_SOURCE)),
-            deploymentId: t.Optional(t.String()),
-            workspaceId: t.Optional(t.String()),
-            sessionId: t.Optional(t.String()),
-            traceId: t.Optional(t.String()),
-            fingerprint: t.Optional(t.String()),
-            labels: t.Optional(t.Array(t.String())),
-            metadata: t.Optional(t.Object({}, { description: "Issue metadata" })),
+            assigneeUserId: t.Optional(t.String({ minLength: 1 })),
+            startAt: t.Optional(t.String({ description: "ISO-8601 start timestamp" })),
+            dueAt: t.Optional(t.String({ description: "ISO-8601 due timestamp" })),
+            deploymentId: t.Optional(t.String({ minLength: 1 })),
+            workspaceId: t.Optional(t.String({ minLength: 1 })),
+            sessionId: t.Optional(t.String({ minLength: 1 })),
+            traceId: t.Optional(t.String({ minLength: 1 })),
+            fingerprint: t.Optional(t.String({ minLength: 1, maxLength: 512 })),
+            labels: t.Optional(t.Array(t.String({ minLength: 1, maxLength: 64 }))),
+            metadata: t.Optional(t.Record(t.String(), t.Unknown(), { description: "Issue metadata" })),
         }),
         async execute(input, ctx) {
             const body = await request(ctx, "/v1/issues", {
@@ -58,17 +90,103 @@ export function registerIssueActions(rl) {
             return body.issue;
         },
     });
+    rl.registerAction("issue.update", {
+        access: "write",
+        description: "Update an Issue, including Project assignment, one-level parentage, ordering, status, dates, or assignee.",
+        inputSchema: t.Object({
+            id: t.String({ minLength: 1, description: "Issue ID" }),
+            title: t.Optional(t.String({ minLength: 1, maxLength: 160 })),
+            description: t.Optional(t.String({ maxLength: 20_000 })),
+            projectId: t.Optional(t.Union([t.String({ minLength: 1 }), t.Null()])),
+            parentIssueId: t.Optional(t.Union([t.String({ minLength: 1 }), t.Null()])),
+            sortOrder: t.Optional(t.Integer({ minimum: 0 })),
+            status: t.Optional(enumSchema("Issue status", ISSUE_STATUS)),
+            priority: t.Optional(enumSchema("Issue priority", ISSUE_PRIORITY)),
+            assigneeUserId: t.Optional(t.Union([t.String({ minLength: 1 }), t.Null()])),
+            startAt: t.Optional(t.Union([t.String(), t.Null()])),
+            dueAt: t.Optional(t.Union([t.String(), t.Null()])),
+            labels: t.Optional(t.Array(t.String({ minLength: 1, maxLength: 64 }))),
+            archived: t.Optional(t.Boolean()),
+        }, { minProperties: 2 }),
+        async execute(input, ctx) {
+            const { id, ...patch } = input;
+            const body = await request(ctx, `/v1/issues/${pathSegment(id)}`, { method: "PATCH", body: JSON.stringify(patch) });
+            return body.issue;
+        },
+    });
     rl.registerAction("issue.comment", {
         access: "write",
-        description: "Add a comment to a Shift Labs issue.",
+        description: "Add a comment to a Shift Labs Issue.",
         inputSchema: t.Object({
-            id: t.String({ description: "Issue ID" }),
-            body: t.String({ description: "Comment body" }),
+            id: t.String({ minLength: 1, description: "Issue ID" }),
+            body: t.String({
+                minLength: 1,
+                maxLength: 20_000,
+                description: "Comment body",
+            }),
         }),
         async execute(input, ctx) {
             const { id, body } = input;
-            const response = await request(ctx, `/v1/issues/${encodeURIComponent(id)}/comments`, { method: "POST", body: JSON.stringify({ body }) });
+            const response = await request(ctx, `/v1/issues/${pathSegment(id)}/comments`, { method: "POST", body: JSON.stringify({ body }) });
             return response.event;
         },
     });
+    rl.registerAction("issue.dependency.list", {
+        access: "read",
+        description: "List the first page of blocking and blocked-by links.",
+        inputSchema: t.Object({
+            id: t.String({ minLength: 1, description: "Issue ID" }),
+            limit: t.Optional(t.Integer({ minimum: 1, maximum: 100 })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...pagination } = input;
+            const body = await request(ctx, withQuery(`/v1/issues/${pathSegment(id)}/dependencies`, issueListParams(pagination)));
+            return body.dependencies;
+        },
+    });
+    rl.registerAction("issue.dependency.listPage", {
+        access: "read",
+        description: "List a cursor-paginated page of Issue dependencies.",
+        inputSchema: t.Object({
+            id: t.String({ minLength: 1, description: "Issue ID" }),
+            cursor: t.Optional(t.String({ minLength: 1 })),
+            limit: t.Optional(t.Integer({ minimum: 1, maximum: 100 })),
+        }),
+        async execute(input, ctx) {
+            const { id, ...pagination } = input;
+            return request(ctx, withQuery(`/v1/issues/${pathSegment(id)}/dependencies`, issueListParams(pagination)));
+        },
+    });
+    rl.registerAction("issue.dependency.add", {
+        access: "write",
+        description: "Declare that one Issue blocks another Issue.",
+        inputSchema: t.Object({
+            blockedIssueId: t.String({
+                minLength: 1,
+                description: "Issue that is blocked",
+            }),
+            blockingIssueId: t.String({
+                minLength: 1,
+                description: "Issue that blocks it",
+            }),
+        }),
+        async execute(input, ctx) {
+            const { blockedIssueId, blockingIssueId } = input;
+            const body = await request(ctx, `/v1/issues/${pathSegment(blockedIssueId)}/dependencies`, { method: "POST", body: JSON.stringify({ blockingIssueId }) });
+            return body.dependency;
+        },
+    });
+    rl.registerAction("issue.dependency.remove", {
+        access: "write",
+        description: "Remove an Issue dependency link.",
+        inputSchema: t.Object({
+            issueId: t.String({ minLength: 1 }),
+            dependencyId: t.String({ minLength: 1 }),
+        }),
+        async execute(input, ctx) {
+            const { issueId, dependencyId } = input;
+            await request(ctx, `/v1/issues/${pathSegment(issueId)}/dependencies/${pathSegment(dependencyId)}`, { method: "DELETE" });
+            return { removed: true };
+        },
+    });
 }

package/dist/plugins/shiftLabs/src/projects.js

@@ -0,0 +1,93 @@
+import * as t from "typebox";
+import { enumSchema, PROJECT_STATUS, pathSegment, request } from "./shared.js";
+const projectListFields = {
+    status: t.Optional(enumSchema("Project status", PROJECT_STATUS)),
+    leadUserId: t.Optional(t.String({ minLength: 1 })),
+    includeArchived: t.Optional(t.Boolean()),
+    cursor: t.Optional(t.String({ minLength: 1, description: "Next-page cursor" })),
+    limit: t.Optional(t.Integer({ minimum: 1, maximum: 100 })),
+};
+function listParams(input) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries((input ?? {}))) {
+        if (value !== undefined)
+            params.set(key, String(value));
+    }
+    return params;
+}
+export function registerProjectActions(rl) {
+    rl.registerAction("project.list", {
+        access: "read",
+        description: "List the first page of concrete Shift Labs Projects.",
+        inputSchema: t.Object(projectListFields),
+        async execute(input, ctx) {
+            const body = await request(ctx, `/v1/projects?${listParams(input)}`);
+            return body.projects;
+        },
+    });
+    rl.registerAction("project.listPage", {
+        access: "read",
+        description: "List a cursor-paginated page of concrete Projects.",
+        inputSchema: t.Object(projectListFields),
+        async execute(input, ctx) {
+            return request(ctx, `/v1/projects?${listParams(input)}`);
+        },
+    });
+    rl.registerAction("project.get", {
+        access: "read",
+        description: "Get a Project and its derived Issue progress.",
+        inputSchema: t.Object({
+            id: t.String({ minLength: 1, description: "Project ID" }),
+        }),
+        async execute(input, ctx) {
+            const { id } = input;
+            const [project, progress] = await Promise.all([
+                request(ctx, `/v1/projects/${pathSegment(id)}`),
+                request(ctx, `/v1/projects/${pathSegment(id)}/progress`),
+            ]);
+            return { project: project.project, progress: progress.progress };
+        },
+    });
+    rl.registerAction("project.create", {
+        access: "write",
+        description: "Create a concrete Project container.",
+        inputSchema: t.Object({
+            name: t.String({
+                minLength: 1,
+                maxLength: 160,
+                description: "Project name",
+            }),
+            description: t.Optional(t.String({ maxLength: 20_000 })),
+            status: t.Optional(enumSchema("Project status", PROJECT_STATUS)),
+            leadUserId: t.Optional(t.String({ minLength: 1 })),
+            startAt: t.Optional(t.String({ description: "ISO-8601 start timestamp" })),
+            targetAt: t.Optional(t.String({ description: "ISO-8601 target timestamp" })),
+        }),
+        async execute(input, ctx) {
+            const body = await request(ctx, "/v1/projects", {
+                method: "POST",
+                body: JSON.stringify(input),
+            });
+            return body.project;
+        },
+    });
+    rl.registerAction("project.update", {
+        access: "write",
+        description: "Update Project lifecycle, ownership, dates, or content.",
+        inputSchema: t.Object({
+            id: t.String({ minLength: 1, description: "Project ID" }),
+            name: t.Optional(t.String({ minLength: 1, maxLength: 160 })),
+            description: t.Optional(t.String({ maxLength: 20_000 })),
+            status: t.Optional(enumSchema("Project status", PROJECT_STATUS)),
+            leadUserId: t.Optional(t.Union([t.String({ minLength: 1 }), t.Null()])),
+            startAt: t.Optional(t.Union([t.String(), t.Null()])),
+            targetAt: t.Optional(t.Union([t.String(), t.Null()])),
+            archived: t.Optional(t.Boolean()),
+        }, { minProperties: 2 }),
+        async execute(input, ctx) {
+            const { id, ...patch } = input;
+            const body = await request(ctx, `/v1/projects/${pathSegment(id)}`, { method: "PATCH", body: JSON.stringify(patch) });
+            return body.project;
+        },
+    });
+}

package/dist/plugins/shiftLabs/src/shared.js

@@ -31,18 +31,17 @@ export function pageRenderUrl(organizationId, slug) {
     return new URL(`/pages/${pathSegment(organizationId)}/${pathSegment(slug)}`, baseUrl()).toString();
 }
 export const ISSUE_STATUS = [
-    "triage",
-    "open",
+    "backlog",
+    "todo",
     "in_progress",
-    "resolved",
-    "closed",
+    "done",
+    "canceled",
 ];
-export const ISSUE_KIND = [
-    "bug",
-    "support",
-    "feature_request",
-    "incident",
-    "task",
+export const PROJECT_STATUS = [
+    "planned",
+    "active",
+    "completed",
+    "canceled",
 ];
 export const ISSUE_PRIORITY = [
     "none",
@@ -51,7 +50,6 @@ export const ISSUE_PRIORITY = [
     "high",
     "urgent",
 ];
-export const ISSUE_SEVERITY = ["info", "warning", "error", "critical"];
 export const ISSUE_SOURCE = [
     "user",
     "agent",
@@ -59,8 +57,25 @@ export const ISSUE_SOURCE = [
     "api",
     "integration",
 ];
+export const ISSUE_VIEW_VISIBILITY = ["personal", "organization"];
+export const ISSUE_VIEW_LAYOUT = ["list", "board", "timeline"];
+export const ISSUE_VIEW_GROUP = [
+    "status",
+    "assignee",
+    "priority",
+    "project",
+];
+export const ISSUE_VIEW_SORT = [
+    "manual",
+    "priority",
+    "startAt",
+    "dueAt",
+    "updatedAt",
+];
 export const PAGE_STATUS = ["draft", "published", "archived"];
 export const PAGE_VISIBILITY = ["org", "invited"];
+export const TRANSCRIPTION_LANGUAGE = ["auto", "en", "he"];
+export const TRANSCRIPT_FORMAT = ["txt", "srt", "vtt", "json"];
 export function enumDescription(name, values) {
     return `${name}: ${values.join(" | ")}`;
 }