toolcraft 0.0.11 → 0.0.13

package/node_modules/@poe-code/task-list/dist/backends/gh-issues.js

@@ -0,0 +1,627 @@
+import { eventsFromState, findEvent } from "../state-machine.js";
+import { AnchorNotFoundError, InvalidTransitionError, OrderMismatchError, TaskNotFoundError } from "../types.js";
+import { createGhClient } from "./gh-issues-client.js";
+import { applyOrder, sortTasks } from "./utils.js";
+const PROJECT_ORGANIZATION_QUERY = `query Project($owner: String!, $number: Int!) {
+  organization(login: $owner) {
+    projectV2(number: $number) {
+      id
+      title
+      field(name: "Status") {
+        ... on ProjectV2SingleSelectField {
+          id
+          options { id name }
+        }
+      }
+    }
+  }
+}`;
+const PROJECT_USER_QUERY = `query Project($owner: String!, $number: Int!) {
+  user(login: $owner) {
+    projectV2(number: $number) {
+      id
+      title
+      field(name: "Status") {
+        ... on ProjectV2SingleSelectField {
+          id
+          options { id name }
+        }
+      }
+    }
+  }
+}`;
+const PROJECT_ITEMS_QUERY = `query Items($projectId: ID!, $after: String) {
+  node(id: $projectId) {
+    ... on ProjectV2 {
+      items(first: 100, after: $after) {
+        nodes {
+          id
+          content {
+            __typename
+            ... on Issue {
+              number
+              title
+              body
+              url
+              createdAt
+              labels(first: 50) { nodes { name } }
+              assignees(first: 20) { nodes { login } }
+              milestone { title }
+            }
+          }
+          fieldValueByName(name: "Status") {
+            ... on ProjectV2ItemFieldSingleSelectValue {
+              name
+            }
+          }
+        }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+}`;
+const ISSUE_QUERY = `query Issue($owner: String!, $repo: String!, $number: Int!) {
+  repository(owner: $owner, name: $repo) {
+    issue(number: $number) {
+      number
+      title
+      body
+      url
+      createdAt
+      labels(first: 50) { nodes { name } }
+      assignees(first: 20) { nodes { login } }
+      milestone { title }
+      projectItems(first: 10) {
+        nodes {
+          id
+          project { id }
+          fieldValueByName(name: "Status") {
+            ... on ProjectV2ItemFieldSingleSelectValue {
+              name
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+const REPOSITORY_QUERY = `query Repository($owner: String!, $repo: String!) {
+  repository(owner: $owner, name: $repo) {
+    id
+  }
+}`;
+const ISSUE_ID_QUERY = `query IssueId($owner: String!, $repo: String!, $number: Int!) {
+  repository(owner: $owner, name: $repo) {
+    issue(number: $number) {
+      id
+    }
+  }
+}`;
+const ISSUE_PROJECT_ITEM_QUERY = `query IssueProjectItem($owner: String!, $repo: String!, $number: Int!) {
+  repository(owner: $owner, name: $repo) {
+    issue(number: $number) {
+      id
+      projectItems(first: 10) {
+        nodes {
+          id
+          project { id }
+        }
+      }
+    }
+  }
+}`;
+const CREATE_ISSUE_MUTATION = `mutation CreateIssue($input: CreateIssueInput!) {
+  createIssue(input: $input) {
+    issue {
+      id
+      number
+    }
+  }
+}`;
+const ADD_PROJECT_ITEM_MUTATION = `mutation AddProjectItem($input: AddProjectV2ItemByIdInput!) {
+  addProjectV2ItemById(input: $input) {
+    item {
+      id
+    }
+  }
+}`;
+const UPDATE_STATUS_MUTATION = `mutation UpdateProjectItemStatus($input: UpdateProjectV2ItemFieldValueInput!) {
+  updateProjectV2ItemFieldValue(input: $input) {
+    projectV2Item {
+      id
+    }
+  }
+}`;
+const UPDATE_ISSUE_MUTATION = `mutation UpdateIssue($input: UpdateIssueInput!) {
+  updateIssue(input: $input) {
+    issue {
+      id
+    }
+  }
+}`;
+const UPDATE_PROJECT_ITEM_POSITION_MUTATION = `mutation UpdateProjectItemPosition($input: UpdateProjectV2ItemPositionInput!) {
+  updateProjectV2ItemPosition(input: $input) {
+    clientMutationId
+  }
+}`;
+const DELETE_PROJECT_ITEM_MUTATION = `mutation DeleteProjectItem($input: DeleteProjectV2ItemInput!) {
+  deleteProjectV2Item(input: $input) {
+    deletedItemId
+  }
+}`;
+export async function ghIssuesBackend(deps) {
+    const client = createGhClient({
+        token: deps.token,
+        endpoint: deps.endpoint,
+        fetch: deps.fetch
+    });
+    const listName = `${deps.project.owner}/${deps.project.number}`;
+    const variables = {
+        owner: deps.project.owner,
+        number: deps.project.number
+    };
+    const organizationResult = await client.graphql(PROJECT_ORGANIZATION_QUERY, variables);
+    let project = organizationResult.organization?.projectV2 ?? null;
+    if (project === null) {
+        const userResult = await client.graphql(PROJECT_USER_QUERY, variables);
+        project = userResult.user?.projectV2 ?? null;
+    }
+    if (project === null) {
+        throw new Error(`Project ${listName} not found or inaccessible.`);
+    }
+    const field = project.field;
+    if (!isStatusField(field)) {
+        throw new Error(`Project ${listName} has no Status field; gh-issues requires one.`);
+    }
+    if (field.options.length === 0) {
+        throw new Error(`Project ${listName} Status field has no options.`);
+    }
+    const session = createSession(project, field);
+    const repoParts = parseRepo(deps.repo);
+    const context = {
+        client,
+        repoOwner: repoParts.owner,
+        repoName: repoParts.name,
+        issueIds: new Map()
+    };
+    function list(name) {
+        assertSingleList(name, listName);
+        return createTasksView(listName, session, context);
+    }
+    return {
+        list,
+        async lists() {
+            return [listName];
+        },
+        async allTasks(filter) {
+            return list(listName).all(filter);
+        },
+        async get(qualifiedId) {
+            const id = parseQualifiedId(qualifiedId, listName);
+            return list(listName).get(id);
+        },
+        async moveBetweenLists(_qualifiedId, _targetList) {
+            throw singleListError(listName);
+        }
+    };
+}
+function createSession(project, field) {
+    const statusOptions = new Map(field.options.map((option) => [option.name, option.id]));
+    const states = field.options.map((option) => option.name);
+    const events = Object.fromEntries(states.map((state) => [state, Object.freeze({ from: "*", to: state })]));
+    const stateMachine = Object.freeze({
+        states: Object.freeze([...states]),
+        initial: states[0],
+        events: Object.freeze(events)
+    });
+    return Object.freeze({
+        projectId: project.id,
+        statusFieldId: field.id,
+        statusOptions,
+        stateMachine
+    });
+}
+function createTasksView(name, session, context) {
+    return {
+        name,
+        stateMachine: session.stateMachine,
+        async all(filter) {
+            if (filter?.includeArchived === true) {
+                return [];
+            }
+            const tasks = await fetchProjectTasks(name, session, context);
+            const filteredTasks = filter?.state === undefined ? tasks : tasks.filter((task) => task.state === filter.state);
+            if (filter?.order === "alphabetical") {
+                return sortTasks(filteredTasks);
+            }
+            if (filter?.order === "created") {
+                return applyOrder(filteredTasks.map((task) => ({
+                    task,
+                    raw: {
+                        created: task.metadata.created
+                    }
+                })), "created");
+            }
+            return filteredTasks;
+        },
+        async get(id) {
+            return fetchIssueTask(id, name, session, context);
+        },
+        /**
+         * GitHub Issues assigns the issue number, so TaskCreate.id is intentionally ignored.
+         */
+        async create(input) {
+            const repositoryId = await resolveRepositoryId(context);
+            const created = await context.client.graphql(CREATE_ISSUE_MUTATION, {
+                input: {
+                    repositoryId,
+                    title: input.name,
+                    body: input.description ?? ""
+                }
+            });
+            const issue = created.createIssue?.issue;
+            const issueId = issue?.id ?? null;
+            const issueNumber = issue?.number ?? null;
+            if (issueId === null || issueNumber === null) {
+                throw new Error("GitHub createIssue response did not include issue id and number.");
+            }
+            context.issueIds.set(issueNumber, issueId);
+            const added = await context.client.graphql(ADD_PROJECT_ITEM_MUTATION, {
+                input: {
+                    projectId: session.projectId,
+                    contentId: issueId
+                }
+            });
+            const projectItemId = added.addProjectV2ItemById?.item?.id ?? null;
+            if (projectItemId === null) {
+                throw new Error("GitHub addProjectV2ItemById response did not include project item id.");
+            }
+            await updateProjectItemStatus(projectItemId, session.stateMachine.initial, session, context);
+            return fetchIssueTask(String(issueNumber), name, session, context);
+        },
+        async update(id, patch) {
+            const input = {};
+            if (patch.name !== undefined) {
+                input.title = patch.name;
+            }
+            if (patch.description !== undefined) {
+                input.body = patch.description;
+            }
+            // metadata writes are out of scope for v1 on gh-issues.
+            if (Object.keys(input).length > 0) {
+                input.id = await resolveIssueId(id, name, context);
+                await context.client.graphql(UPDATE_ISSUE_MUTATION, {
+                    input
+                });
+            }
+            return fetchIssueTask(id, name, session, context);
+        },
+        async fire(id, event, _opts) {
+            if (!session.statusOptions.has(event)) {
+                throw new InvalidTransitionError({
+                    event,
+                    to: event,
+                    reason: `Unknown gh-issues Status state "${event}".`
+                });
+            }
+            const projectItemId = await resolveProjectItemId(id, name, session, context);
+            // opts.metadataPatch writes are out of scope for v1 on gh-issues.
+            await updateProjectItemStatus(projectItemId, event, session, context);
+            return fetchIssueTask(id, name, session, context);
+        },
+        async canFire(id, event) {
+            return findEvent(session.stateMachine, id, event) !== undefined;
+        },
+        async events(id) {
+            return eventsFromState(session.stateMachine, id);
+        },
+        async delete(id) {
+            const projectItemId = await resolveProjectItemId(id, name, session, context);
+            await context.client.graphql(DELETE_PROJECT_ITEM_MUTATION, {
+                input: {
+                    projectId: session.projectId,
+                    itemId: projectItemId
+                }
+            });
+        },
+        async move(id, anchor) {
+            const projectItemId = await resolveProjectItemId(id, name, session, context);
+            const afterId = await resolveMoveAfterId(id, anchor, name, session, context);
+            await updateProjectItemPosition(projectItemId, afterId, session, context);
+            return fetchIssueTask(id, name, session, context);
+        },
+        async reorder(ids) {
+            const currentTasks = await fetchProjectTasks(name, session, context);
+            const currentIds = currentTasks.map((task) => task.id);
+            const currentSet = new Set(currentIds);
+            const inputSet = new Set(ids);
+            const seenInputIds = new Set();
+            const missing = currentIds.filter((id) => !inputSet.has(id));
+            const extra = ids.filter((id) => {
+                if (!currentSet.has(id)) {
+                    return true;
+                }
+                if (seenInputIds.has(id)) {
+                    return true;
+                }
+                seenInputIds.add(id);
+                return false;
+            });
+            if (missing.length > 0 || extra.length > 0) {
+                throw new OrderMismatchError({ missing, extra });
+            }
+            const itemIdsByTaskId = new Map(currentTasks.map((task) => [task.id, projectItemIdFromTask(task)]));
+            let afterId = null;
+            for (const id of ids) {
+                const projectItemId = itemIdsByTaskId.get(id);
+                if (projectItemId === undefined) {
+                    throw new OrderMismatchError({ missing: [id], extra: [] });
+                }
+                await updateProjectItemPosition(projectItemId, afterId, session, context);
+                afterId = projectItemId;
+            }
+            return fetchProjectTasks(name, session, context);
+        }
+    };
+}
+async function resolveRepositoryId(context) {
+    if (context.repositoryId !== undefined) {
+        return context.repositoryId;
+    }
+    const result = await context.client.graphql(REPOSITORY_QUERY, {
+        owner: context.repoOwner,
+        repo: context.repoName
+    });
+    const repositoryId = result.repository?.id ?? null;
+    if (repositoryId === null) {
+        throw new Error(`Repository ${context.repoOwner}/${context.repoName} not found or inaccessible.`);
+    }
+    context.repositoryId = repositoryId;
+    return repositoryId;
+}
+async function resolveIssueId(id, listName, context) {
+    const issueNumber = parseIssueNumber(id, listName);
+    const cachedIssueId = context.issueIds.get(issueNumber);
+    if (cachedIssueId !== undefined) {
+        return cachedIssueId;
+    }
+    const result = await context.client.graphql(ISSUE_ID_QUERY, {
+        owner: context.repoOwner,
+        repo: context.repoName,
+        number: issueNumber
+    });
+    const issueId = result.repository?.issue?.id ?? null;
+    if (issueId === null) {
+        throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
+    }
+    context.issueIds.set(issueNumber, issueId);
+    return issueId;
+}
+async function resolveProjectItemId(id, listName, session, context) {
+    const issueNumber = parseIssueNumber(id, listName);
+    const result = await context.client.graphql(ISSUE_PROJECT_ITEM_QUERY, {
+        owner: context.repoOwner,
+        repo: context.repoName,
+        number: issueNumber
+    });
+    const issue = result.repository?.issue ?? null;
+    if (issue === null) {
+        throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
+    }
+    if (issue.id !== undefined && issue.id !== null) {
+        context.issueIds.set(issueNumber, issue.id);
+    }
+    const projectItem = issue.projectItems?.nodes?.find((item) => item.project?.id === session.projectId) ?? null;
+    if (projectItem === null) {
+        throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
+    }
+    return projectItem.id;
+}
+async function updateProjectItemStatus(projectItemId, state, session, context) {
+    const optionId = session.statusOptions.get(state);
+    if (optionId === undefined) {
+        throw new InvalidTransitionError({
+            to: state,
+            reason: `Unknown gh-issues Status state "${state}".`
+        });
+    }
+    await context.client.graphql(UPDATE_STATUS_MUTATION, {
+        input: {
+            projectId: session.projectId,
+            itemId: projectItemId,
+            fieldId: session.statusFieldId,
+            value: {
+                singleSelectOptionId: optionId
+            }
+        }
+    });
+}
+async function updateProjectItemPosition(projectItemId, afterId, session, context) {
+    await context.client.graphql(UPDATE_PROJECT_ITEM_POSITION_MUTATION, {
+        input: {
+            projectId: session.projectId,
+            itemId: projectItemId,
+            afterId
+        }
+    });
+}
+async function resolveMoveAfterId(movingId, anchor, listName, session, context) {
+    if ("position" in anchor) {
+        if (anchor.position === "top") {
+            return null;
+        }
+        const tasks = await fetchProjectTasks(listName, session, context);
+        for (let index = tasks.length - 1; index >= 0; index -= 1) {
+            const task = tasks[index];
+            if (task.id !== movingId) {
+                return projectItemIdFromTask(task);
+            }
+        }
+        return null;
+    }
+    const anchorId = "before" in anchor ? anchor.before : anchor.after;
+    let anchorProjectItemId;
+    try {
+        anchorProjectItemId = await resolveProjectItemId(anchorId, listName, session, context);
+    }
+    catch (error) {
+        if (error instanceof TaskNotFoundError) {
+            throw new AnchorNotFoundError(anchorId);
+        }
+        throw error;
+    }
+    if ("after" in anchor) {
+        return anchorProjectItemId;
+    }
+    const tasks = await fetchProjectTasks(listName, session, context);
+    const anchorIndex = tasks.findIndex((task) => task.id === anchorId);
+    if (anchorIndex < 0) {
+        throw new AnchorNotFoundError(anchorId);
+    }
+    for (let index = anchorIndex - 1; index >= 0; index -= 1) {
+        const predecessor = tasks[index];
+        if (predecessor.id !== movingId) {
+            return projectItemIdFromTask(predecessor);
+        }
+    }
+    return null;
+}
+async function fetchProjectTasks(listName, session, context) {
+    const tasks = [];
+    let after = null;
+    do {
+        const result = await context.client.graphql(PROJECT_ITEMS_QUERY, {
+            projectId: session.projectId,
+            after
+        });
+        const items = result.node?.items;
+        for (const item of items?.nodes ?? []) {
+            const task = mapProjectItemToTask(item, listName, session);
+            if (task !== null) {
+                tasks.push(task);
+            }
+        }
+        after = items?.pageInfo?.hasNextPage === true ? (items.pageInfo.endCursor ?? null) : null;
+    } while (after !== null);
+    return tasks;
+}
+async function fetchIssueTask(id, listName, session, context) {
+    const issueNumber = parseIssueNumber(id, listName);
+    const result = await context.client.graphql(ISSUE_QUERY, {
+        owner: context.repoOwner,
+        repo: context.repoName,
+        number: issueNumber
+    });
+    const issue = result.repository?.issue ?? null;
+    if (issue === null) {
+        throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
+    }
+    const projectItem = issue.projectItems?.nodes?.find((item) => item.project?.id === session.projectId) ?? null;
+    if (projectItem === null) {
+        throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
+    }
+    return mapIssueToTask({
+        issue,
+        projectItemId: projectItem.id,
+        statusName: projectItem.fieldValueByName?.name ?? null,
+        listName,
+        initialState: session.stateMachine.initial
+    });
+}
+function parseIssueNumber(id, listName) {
+    const issueNumber = Number(id);
+    if (!Number.isInteger(issueNumber) || issueNumber < 1) {
+        throw new TaskNotFoundError(`Task "${listName}/${id}" not found.`);
+    }
+    return issueNumber;
+}
+function mapProjectItemToTask(item, listName, session) {
+    const content = item.content;
+    if (!isIssueNode(content)) {
+        return null;
+    }
+    return mapIssueToTask({
+        issue: content,
+        projectItemId: item.id,
+        statusName: item.fieldValueByName?.name ?? null,
+        listName,
+        initialState: session.stateMachine.initial
+    });
+}
+function isIssueNode(value) {
+    return (isRecord(value) &&
+        value.__typename === "Issue" &&
+        typeof value.number === "number" &&
+        typeof value.title === "string" &&
+        typeof value.url === "string" &&
+        typeof value.createdAt === "string");
+}
+function mapIssueToTask(options) {
+    const id = String(options.issue.number);
+    const labels = (options.issue.labels?.nodes ?? [])
+        .filter((node) => node !== null)
+        .map((node) => node.name);
+    const assignees = (options.issue.assignees?.nodes ?? [])
+        .filter((node) => node !== null)
+        .map((node) => node.login);
+    return {
+        list: options.listName,
+        id,
+        qualifiedId: `${options.listName}/${id}`,
+        name: options.issue.title,
+        description: options.issue.body ?? "",
+        state: options.statusName ?? options.initialState,
+        metadata: {
+            url: options.issue.url,
+            labels,
+            assignees,
+            milestone: options.issue.milestone?.title ?? null,
+            projectItemId: options.projectItemId,
+            created: options.issue.createdAt
+        }
+    };
+}
+function projectItemIdFromTask(task) {
+    const projectItemId = task.metadata.projectItemId;
+    if (typeof projectItemId !== "string") {
+        throw new Error(`Task "${task.qualifiedId}" is missing GitHub project item metadata.`);
+    }
+    return projectItemId;
+}
+function parseRepo(repo) {
+    const parts = repo.split("/");
+    if (parts.length !== 2 || parts[0] === "" || parts[1] === "") {
+        throw new Error(`Invalid GitHub repository "${repo}". Expected "owner/name".`);
+    }
+    return {
+        owner: parts[0],
+        name: parts[1]
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStatusOption(value) {
+    return isRecord(value) && typeof value.id === "string" && typeof value.name === "string";
+}
+function isStatusField(value) {
+    return (isRecord(value) &&
+        typeof value.id === "string" &&
+        Array.isArray(value.options) &&
+        value.options.every(isStatusOption));
+}
+function assertSingleList(name, listName) {
+    if (name !== listName) {
+        throw singleListError(listName);
+    }
+}
+function singleListError(listName) {
+    return new Error(`gh-issues backend has a single list ${listName}`);
+}
+function parseQualifiedId(qualifiedId, listName) {
+    const prefix = `${listName}/`;
+    if (!qualifiedId.startsWith(prefix) || qualifiedId.length === prefix.length) {
+        throw new Error(`Invalid qualified task id "${qualifiedId}".`);
+    }
+    return qualifiedId.slice(prefix.length);
+}