@sascha384/tic 3.0.0 → 4.0.0

package/dist/backends/gitlab/index.js

@@ -1,11 +1,121 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-const execFileAsync = promisify(execFile);
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
 import { BaseBackend } from '../types.js';
-import { glab, glabExec, glabExecSync, glabSync } from './glab.js';
-import { detectGroup } from './group.js';
+import { GitLabApiClient } from './api.js';
+import { parseGitLabRemote } from './remote.js';
+import { mapWorkItemToWorkItem, mapNoteToComment } from './mappers.js';
+import { AuthError } from '../shared/api-client.js';
+import { getGitLabToken, getGitLabPat, authenticateGitLab, } from '../../auth/gitlab.js';
 import { slugifyTemplateName } from '../local/templates.js';
-import { mapIssueToWorkItem, mapEpicToWorkItem, mapNoteToComment, } from './mappers.js';
+const WORK_ITEM_FIELDS = `
+  id iid title state createdAt updatedAt
+  workItemType { name }
+  widgets {
+    ... on WorkItemWidgetDescription { description }
+    ... on WorkItemWidgetAssignees { assignees { nodes { username } } }
+    ... on WorkItemWidgetLabels { labels { nodes { title } } }
+    ... on WorkItemWidgetMilestone { milestone { title } }
+    ... on WorkItemWidgetHierarchy {
+      parent { id iid workItemType { name } }
+    }
+    __typename
+  }
+`;
+const WORK_ITEM_DETAIL_FIELDS = `
+  id iid title state createdAt updatedAt
+  workItemType { name }
+  widgets {
+    ... on WorkItemWidgetDescription { description }
+    ... on WorkItemWidgetAssignees { assignees { nodes { username } } }
+    ... on WorkItemWidgetLabels { labels { nodes { title } } }
+    ... on WorkItemWidgetMilestone { milestone { title } }
+    ... on WorkItemWidgetHierarchy {
+      parent { id iid workItemType { name } }
+      children { nodes { id iid title state workItemType { name } } }
+    }
+    ... on WorkItemWidgetNotes {
+      discussions {
+        nodes { notes { nodes { author { username } createdAt body } } }
+      }
+    }
+    __typename
+  }
+`;
+const LIST_PROJECT_ISSUES = `query($fullPath: ID!, $cursor: String) {
+  project(fullPath: $fullPath) {
+    workItems(types: [ISSUE, TASK], first: 100, after: $cursor) {
+      nodes { ${WORK_ITEM_FIELDS} }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+}`;
+const LIST_GROUP_EPICS = `query($fullPath: ID!, $cursor: String) {
+  group(fullPath: $fullPath) {
+    workItems(types: [EPIC], first: 100, after: $cursor) {
+      nodes { ${WORK_ITEM_FIELDS} }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+}`;
+const GET_WORK_ITEM = `query($id: WorkItemID!) {
+  workItem(id: $id) { ${WORK_ITEM_DETAIL_FIELDS} }
+}`;
+const LOOKUP_PROJECT_ITEM = `query($fullPath: ID!, $iid: String!) {
+  project(fullPath: $fullPath) {
+    workItems(iid: $iid, first: 1) {
+      nodes { id iid workItemType { name } }
+    }
+  }
+}`;
+const LOOKUP_GROUP_ITEM = `query($fullPath: ID!, $iid: String!) {
+  group(fullPath: $fullPath) {
+    workItems(iid: $iid, types: [EPIC], first: 1) {
+      nodes { id iid workItemType { name } }
+    }
+  }
+}`;
+const CREATE_WORK_ITEM = `mutation($input: WorkItemCreateInput!) {
+  workItemCreate(input: $input) {
+    workItem { ${WORK_ITEM_FIELDS} }
+    errors
+  }
+}`;
+const UPDATE_WORK_ITEM = `mutation($input: WorkItemUpdateInput!) {
+  workItemUpdate(input: $input) {
+    workItem { ${WORK_ITEM_FIELDS} }
+    errors
+  }
+}`;
+const DELETE_WORK_ITEM = `mutation($input: WorkItemDeleteInput!) {
+  workItemDelete(input: $input) { errors }
+}`;
+const CREATE_NOTE = `mutation($input: CreateNoteInput!) {
+  createNote(input: $input) {
+    note { id body author { username } createdAt }
+    errors
+  }
+}`;
+const WORK_ITEM_TYPES = `query($projectPath: ID!) {
+  project(fullPath: $projectPath) {
+    workItemTypes { nodes { id name } }
+  }
+}`;
+const PROJECT_MEMBERS = `query($fullPath: ID!, $cursor: String) {
+  project(fullPath: $fullPath) {
+    projectMembers(first: 100, after: $cursor) {
+      nodes { user { username } }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+}`;
+const PROJECT_MILESTONES = `query($fullPath: ID!, $cursor: String) {
+  project(fullPath: $fullPath) {
+    milestones(first: 100, after: $cursor) {
+      nodes { title startDate dueDate }
+      pageInfo { hasNextPage endCursor }
+    }
+  }
+}`;
 const TEMPLATES_DIR = '.gitlab/issue_templates';
 function parseId(id) {
     const match = id.match(/^(issue|epic)-(\d+)$/);
@@ -14,20 +124,52 @@ function parseId(id) {
     }
     return { type: match[1], iid: match[2] };
 }
+async function queryWorkItemTypes(api, projectPath) {
+    const data = await api.graphql(WORK_ITEM_TYPES, {
+        projectPath,
+    });
+    const m = new Map();
+    for (const t of data.project.workItemTypes.nodes) {
+        m.set(t.name.toLowerCase(), t.id);
+    }
+    return m;
+}
 export class GitLabBackend extends BaseBackend {
+    api;
+    remote;
+    typeIds;
+    gidCache = new Map();
     cwd;
-    group;
-    cachedIterations = null;
-    /** Maps template slug → original GitLab filename (without .md) */
-    templateNameCache = new Map();
-    constructor(cwd) {
+    cachedMilestones = null;
+    constructor(api, remote, typeIds, cwd) {
         super(60_000);
+        this.api = api;
+        this.remote = remote;
+        this.typeIds = typeIds;
         this.cwd = cwd;
-        glabExecSync(['auth', 'status'], cwd);
-        this.group = detectGroup(cwd);
+    }
+    static async create(cwd, options) {
+        const remote = parseGitLabRemote(cwd);
+        let token = getGitLabToken();
+        if (!token)
+            token = getGitLabPat();
+        if (!token) {
+            if (options?.skipAuth) {
+                throw new AuthError('GitLab authentication required. Run "tic auth login gitlab" to authenticate.');
+            }
+            token = await authenticateGitLab({
+                onCode: (code, url) => {
+                    console.log(`\nGitLab authentication required.`);
+                    console.log(`Visit ${url} and enter code: ${code}\n`);
+                },
+            });
+        }
+        const api = new GitLabApiClient(token);
+        const typeIds = await queryWorkItemTypes(api, remote.fullPath);
+        return new GitLabBackend(api, remote, typeIds, cwd);
     }
     onCacheInvalidate() {
-        this.cachedIterations = null;
+        this.cachedMilestones = null;
     }
     getCapabilities() {
         return {
@@ -67,8 +209,13 @@ export class GitLabBackend extends BaseBackend {
     }
     async getAssignees() {
         try {
-            const members = await glab(['api', 'projects/:fullpath/members/all', '--paginate'], this.cwd);
-            return members.map((m) => m.username);
+            const members = [];
+            for await (const page of this.api.paginate(PROJECT_MEMBERS, { fullPath: this.remote.fullPath }, (data) => data.project.projectMembers)) {
+                for (const m of page) {
+                    members.push(m.user.username);
+                }
+            }
+            return members;
         }
         catch {
             return [];
@@ -78,117 +225,164 @@ export class GitLabBackend extends BaseBackend {
         return this.getLabelsFromCache();
     }
     async getIterations() {
-        const iterations = await this.fetchIterations();
-        return iterations.map((i) => i.title);
+        const ms = await this.fetchMilestones();
+        return ms.map((m) => m.title);
     }
     async getCurrentIteration() {
-        const iterations = await this.fetchIterations();
+        const ms = await this.fetchMilestones();
         const today = new Date().toISOString().split('T')[0];
-        const current = iterations.find((i) => i.start_date <= today && today <= i.due_date);
-        return current?.title ?? '';
+        const cur = ms.find((m) => m.startDate <= today && today <= m.dueDate);
+        return cur?.title ?? '';
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async setCurrentIteration(_name) {
-        // No-op — current iteration is determined by date range
+        // No-op — determined by date range
     }
     async listWorkItems(iteration) {
-        // Fetch issues
-        const issueArgs = [
-            'issue',
-            'list',
-            '-F',
-            'json',
-            '--per-page',
-            '100',
-            '--all',
-        ];
-        const issues = await glab(issueArgs, this.cwd);
-        let issueItems = issues.map(mapIssueToWorkItem);
+        const issues = [];
+        for await (const page of this.api.paginate(LIST_PROJECT_ISSUES, { fullPath: this.remote.fullPath }, (d) => d.project.workItems)) {
+            issues.push(...page);
+        }
+        const epics = [];
+        for await (const page of this.api.paginate(LIST_GROUP_EPICS, { fullPath: this.remote.group }, (d) => d.group.workItems)) {
+            epics.push(...page);
+        }
+        const all = [...issues, ...epics];
+        const items = [];
+        for (const gl of all) {
+            const item = mapWorkItemToWorkItem(gl);
+            this.cacheGid(item.id, gl.id);
+            items.push(item);
+        }
+        let filtered = items;
         if (iteration) {
-            issueItems = issueItems.filter((item) => item.iteration === iteration);
+            filtered = items.filter((i) => i.iteration === iteration);
         }
-        // Fetch epics
-        const encodedGroup = encodeURIComponent(this.group);
-        const epics = await glab(['api', `groups/${encodedGroup}/epics`, '--paginate'], this.cwd);
-        const epicItems = epics.map(mapEpicToWorkItem);
-        // Merge and sort by updated descending
-        const allItems = [...epicItems, ...issueItems];
-        allItems.sort((a, b) => b.updated.localeCompare(a.updated));
-        return allItems;
+        filtered.sort((a, b) => b.updated.localeCompare(a.updated));
+        return filtered;
     }
     async getWorkItem(id) {
-        const { type, iid } = parseId(id);
-        if (type === 'issue') {
-            const issue = await glab(['issue', 'view', iid, '-F', 'json'], this.cwd);
-            const item = mapIssueToWorkItem(issue);
-            // Fetch notes via API
-            const notes = await glab(['api', `projects/:fullpath/issues/${iid}/notes`, '--paginate'], this.cwd);
-            item.comments = notes.map(mapNoteToComment);
-            return item;
-        }
-        // Epic
-        const encodedGroup = encodeURIComponent(this.group);
-        const epic = await glab(['api', `groups/${encodedGroup}/epics/${iid}`], this.cwd);
-        const item = mapEpicToWorkItem(epic);
-        // Fetch epic notes
-        const notes = await glab(['api', `groups/${encodedGroup}/epics/${iid}/notes`, '--paginate'], this.cwd);
-        item.comments = notes.map(mapNoteToComment);
+        const gid = await this.resolveGid(id);
+        const data = await this.api.graphql(GET_WORK_ITEM, {
+            id: gid,
+        });
+        const item = mapWorkItemToWorkItem(data.workItem);
+        this.cacheGid(item.id, data.workItem.id);
         return item;
     }
     async createWorkItem(data) {
         this.validateFields(data);
-        if (data.type === 'epic') {
-            return this.createEpic(data);
+        const isEpic = data.type === 'epic';
+        const typeName = isEpic ? 'epic' : 'issue';
+        const typeId = this.typeIds.get(typeName);
+        if (!typeId) {
+            throw new Error(`Work item type "${typeName}" not found in project`);
+        }
+        const input = {
+            title: data.title,
+            workItemTypeId: typeId,
+            namespacePath: isEpic ? this.remote.group : this.remote.fullPath,
+        };
+        if (data.description) {
+            input['descriptionWidget'] = { description: data.description };
+        }
+        const res = await this.api.graphql(CREATE_WORK_ITEM, {
+            input,
+        });
+        if (res.workItemCreate.errors.length > 0) {
+            throw new Error(`Failed to create work item: ${res.workItemCreate.errors.join(', ')}`);
+        }
+        const created = res.workItemCreate.workItem;
+        const item = mapWorkItemToWorkItem(created);
+        this.cacheGid(item.id, created.id);
+        const needsUpdate = data.assignee ||
+            data.labels.length > 0 ||
+            data.iteration ||
+            data.status === 'closed';
+        if (needsUpdate) {
+            const partial = {};
+            if (data.assignee)
+                partial.assignee = data.assignee;
+            if (data.labels.length > 0)
+                partial.labels = data.labels;
+            if (data.iteration)
+                partial.iteration = data.iteration;
+            if (data.status === 'closed')
+                partial.status = 'closed';
+            const updates = this.buildWidgetUpdates(partial);
+            return this.applyUpdate(created.id, updates, data.status === 'closed' ? 'closed' : undefined);
         }
-        return this.createIssue(data);
+        return item;
     }
     async updateWorkItem(id, data) {
         this.validateFields(data);
-        const { type, iid } = parseId(id);
-        if (type === 'issue') {
-            return this.updateIssue(iid, data);
+        const gid = await this.resolveGid(id);
+        const updates = this.buildWidgetUpdates(data);
+        const hasChanges = updates.length > 0 ||
+            data.title !== undefined ||
+            data.status !== undefined;
+        if (hasChanges) {
+            return this.applyUpdate(gid, updates, data.status, data.title);
         }
-        return this.updateEpic(iid, data);
+        return this.getWorkItem(id);
     }
     async deleteWorkItem(id) {
-        const { type, iid } = parseId(id);
-        if (type === 'issue') {
-            await glabExec(['issue', 'delete', iid, '--yes'], this.cwd);
-            return;
+        const gid = await this.resolveGid(id);
+        const res = await this.api.graphql(DELETE_WORK_ITEM, {
+            input: { id: gid },
+        });
+        if (res.workItemDelete.errors.length > 0) {
+            throw new Error(`Failed to delete work item: ${res.workItemDelete.errors.join(', ')}`);
         }
-        const encodedGroup = encodeURIComponent(this.group);
-        await glab(['api', `groups/${encodedGroup}/epics/${iid}`, '-X', 'DELETE'], this.cwd);
+        this.gidCache.delete(id);
     }
     async addComment(workItemId, comment) {
-        const { type, iid } = parseId(workItemId);
-        if (type === 'issue') {
-            await glabExec(['issue', 'note', iid, '-m', comment.body], this.cwd);
-        }
-        else {
-            const encodedGroup = encodeURIComponent(this.group);
-            await glab([
-                'api',
-                `groups/${encodedGroup}/epics/${iid}/notes`,
-                '-X',
-                'POST',
-                '-f',
-                `body=${comment.body}`,
-            ], this.cwd);
+        const gid = await this.resolveGid(workItemId);
+        const res = await this.api.graphql(CREATE_NOTE, {
+            input: { noteableId: gid, body: comment.body },
+        });
+        if (res.createNote.errors.length > 0) {
+            throw new Error(`Failed to add comment: ${res.createNote.errors.join(', ')}`);
         }
-        return {
-            author: comment.author,
-            date: new Date().toISOString(),
-            body: comment.body,
-        };
+        return mapNoteToComment(res.createNote.note);
     }
     async getChildren(id) {
-        const { type, iid } = parseId(id);
-        if (type === 'issue') {
+        const { type } = parseId(id);
+        if (type === 'issue')
             return [];
+        const gid = await this.resolveGid(id);
+        const data = await this.api.graphql(GET_WORK_ITEM, {
+            id: gid,
+        });
+        for (const w of data.workItem.widgets) {
+            if (w.__typename === 'WorkItemWidgetHierarchy' &&
+                'children' in w &&
+                w.children) {
+                const children = w.children.nodes;
+                return children.map((c) => {
+                    const ct = c.workItemType.name.toLowerCase();
+                    const cid = `${ct}-${c.iid}`;
+                    this.cacheGid(cid, c.id);
+                    return {
+                        id: cid,
+                        title: c.title,
+                        description: '',
+                        status: c.state === 'CLOSED' ? 'closed' : 'open',
+                        type: ct,
+                        assignee: '',
+                        labels: [],
+                        iteration: '',
+                        priority: 'medium',
+                        created: '',
+                        updated: '',
+                        parent: id,
+                        dependsOn: [],
+                        comments: [],
+                    };
+                });
+            }
         }
-        const encodedGroup = encodeURIComponent(this.group);
-        const issues = await glab(['api', `groups/${encodedGroup}/epics/${iid}/issues`, '--paginate'], this.cwd);
-        return issues.map(mapIssueToWorkItem);
+        return [];
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await
     async getDependents(_id) {
@@ -197,315 +391,189 @@ export class GitLabBackend extends BaseBackend {
     getItemUrl(id) {
         const { type, iid } = parseId(id);
         if (type === 'issue') {
-            const result = glabSync(['issue', 'view', iid, '-F', 'json'], this.cwd);
-            return result.web_url;
+            return `https://${this.remote.host}/${this.remote.fullPath}/-/issues/${iid}`;
         }
-        return `https://gitlab.com/groups/${this.group}/-/epics/${iid}`;
+        return `https://${this.remote.host}/groups/${this.remote.group}/-/epics/${iid}`;
     }
     async openItem(id) {
-        const { type, iid } = parseId(id);
-        if (type === 'issue') {
-            await glabExec(['issue', 'view', iid, '--web'], this.cwd);
-            return;
-        }
-        const url = `https://gitlab.com/groups/${this.group}/-/epics/${iid}`;
-        await execFileAsync('open', [url]);
+        const url = this.getItemUrl(id);
+        const { default: open } = await import('open');
+        await open(url);
     }
     async listTemplates() {
-        let items;
+        const dir = path.join(this.cwd, TEMPLATES_DIR);
         try {
-            items = await glab([
-                'api',
-                'projects/:fullpath/repository/tree',
-                '--paginate',
-                '-f',
-                `path=${TEMPLATES_DIR}`,
-            ], this.cwd);
+            const files = await fs.readdir(dir);
+            return Promise.all(files
+                .filter((f) => f.endsWith('.md'))
+                .map(async (f) => {
+                const name = f.replace(/\.md$/, '');
+                const slug = slugifyTemplateName(name);
+                const content = await fs.readFile(path.join(dir, f), 'utf-8');
+                return { slug, name, description: content };
+            }));
         }
         catch {
             return [];
         }
-        if (!Array.isArray(items))
-            return [];
-        this.templateNameCache.clear();
-        const templates = [];
-        for (const item of items) {
-            if (item.type !== 'blob' || !item.name.endsWith('.md'))
-                continue;
-            const name = item.name.replace(/\.md$/, '');
-            const slug = slugifyTemplateName(name);
-            this.templateNameCache.set(slug, name);
-            let description = '';
-            try {
-                const encodedPath = encodeURIComponent(item.path);
-                const file = await glab([
-                    'api',
-                    `projects/:fullpath/repository/files/${encodedPath}`,
-                    '-f',
-                    'ref=HEAD',
-                ], this.cwd);
-                description = Buffer.from(file.content, 'base64').toString('utf-8');
-            }
-            catch {
-                // If file read fails, leave description empty
-            }
-            templates.push({ slug, name, description });
-        }
-        return templates;
-    }
-    /** Resolve a slug to the original GitLab filename (without .md). Falls back to slug. */
-    resolveTemplateName(slug) {
-        return this.templateNameCache.get(slug) ?? slug;
     }
     async getTemplate(slug) {
-        const name = this.resolveTemplateName(slug);
-        const filePath = `${TEMPLATES_DIR}/${name}.md`;
-        const encodedPath = encodeURIComponent(filePath);
-        const file = await glab([
-            'api',
-            `projects/:fullpath/repository/files/${encodedPath}`,
-            '-f',
-            'ref=HEAD',
-        ], this.cwd);
-        const content = Buffer.from(file.content, 'base64').toString('utf-8');
-        return { slug, name, description: content };
+        const templates = await this.listTemplates();
+        const found = templates.find((tmpl) => tmpl.slug === slug);
+        if (!found)
+            throw new Error(`Template not found: ${slug}`);
+        return found;
     }
     async createTemplate(template) {
+        const dir = path.join(this.cwd, TEMPLATES_DIR);
+        await fs.mkdir(dir, { recursive: true });
         const slug = slugifyTemplateName(template.name);
-        const filePath = `${TEMPLATES_DIR}/${template.name}.md`;
-        const encodedPath = encodeURIComponent(filePath);
+        const fp = path.join(dir, `${template.name}.md`);
         const content = template.description ?? '';
-        await glabExec([
-            'api',
-            `projects/:fullpath/repository/files/${encodedPath}`,
-            '-X',
-            'POST',
-            '-f',
-            'branch=main',
-            '-f',
-            `content=${content}`,
-            '-f',
-            `commit_message=Add issue template: ${template.name}`,
-        ], this.cwd);
-        this.templateNameCache.set(slug, template.name);
+        await fs.writeFile(fp, content, 'utf-8');
         return { slug, name: template.name, description: content };
     }
     async updateTemplate(oldSlug, template) {
         const newSlug = slugifyTemplateName(template.name);
-        const oldName = this.resolveTemplateName(oldSlug);
         const content = template.description ?? '';
         if (oldSlug !== newSlug) {
-            // Name changed — delete old file and create new one
-            const oldPath = `${TEMPLATES_DIR}/${oldName}.md`;
-            const encodedOldPath = encodeURIComponent(oldPath);
+            const old = await this.getTemplate(oldSlug);
+            const oldPath = path.join(this.cwd, TEMPLATES_DIR, `${old.name}.md`);
             try {
-                await glabExec([
-                    'api',
-                    `projects/:fullpath/repository/files/${encodedOldPath}`,
-                    '-X',
-                    'DELETE',
-                    '-f',
-                    'branch=main',
-                    '-f',
-                    `commit_message=Rename issue template: ${oldName} -> ${template.name}`,
-                ], this.cwd);
+                await fs.unlink(oldPath);
             }
             catch {
-                // Old file may not exist; continue with create
+                // Old file may not exist
             }
-            const newPath = `${TEMPLATES_DIR}/${template.name}.md`;
-            const encodedNewPath = encodeURIComponent(newPath);
-            await glabExec([
-                'api',
-                `projects/:fullpath/repository/files/${encodedNewPath}`,
-                '-X',
-                'POST',
-                '-f',
-                'branch=main',
-                '-f',
-                `content=${content}`,
-                '-f',
-                `commit_message=Add issue template: ${template.name}`,
-            ], this.cwd);
-            this.templateNameCache.delete(oldSlug);
-            this.templateNameCache.set(newSlug, template.name);
-        }
-        else {
-            // Same slug — update in place
-            const filePath = `${TEMPLATES_DIR}/${oldName}.md`;
-            const encodedPath = encodeURIComponent(filePath);
-            await glabExec([
-                'api',
-                `projects/:fullpath/repository/files/${encodedPath}`,
-                '-X',
-                'PUT',
-                '-f',
-                'branch=main',
-                '-f',
-                `content=${content}`,
-                '-f',
-                `commit_message=Update issue template: ${oldName}`,
-            ], this.cwd);
         }
+        const dir = path.join(this.cwd, TEMPLATES_DIR);
+        await fs.mkdir(dir, { recursive: true });
+        const fp = path.join(dir, `${template.name}.md`);
+        await fs.writeFile(fp, content, 'utf-8');
         return { slug: newSlug, name: template.name, description: content };
     }
     async deleteTemplate(slug) {
-        const name = this.resolveTemplateName(slug);
-        const filePath = `${TEMPLATES_DIR}/${name}.md`;
-        const encodedPath = encodeURIComponent(filePath);
-        await glabExec([
-            'api',
-            `projects/:fullpath/repository/files/${encodedPath}`,
-            '-X',
-            'DELETE',
-            '-f',
-            'branch=main',
-            '-f',
-            `commit_message=Delete issue template: ${name}`,
-        ], this.cwd);
-        this.templateNameCache.delete(slug);
-    }
-    async fetchIterations() {
-        if (this.cachedIterations)
-            return this.cachedIterations;
-        const encodedGroup = encodeURIComponent(this.group);
-        this.cachedIterations = await glab(['api', `groups/${encodedGroup}/iterations`, '--paginate'], this.cwd);
-        return this.cachedIterations;
-    }
-    async ensureLabels(labels) {
-        for (const label of labels) {
-            try {
-                await glabExec(['label', 'create', label], this.cwd);
-            }
-            catch {
-                // Label already exists — ignore
-            }
-        }
+        const found = await this.getTemplate(slug);
+        const fp = path.join(this.cwd, TEMPLATES_DIR, `${found.name}.md`);
+        await fs.unlink(fp);
     }
-    async createIssue(data) {
-        if (data.labels.length > 0) {
-            await this.ensureLabels(data.labels);
-        }
-        const args = ['issue', 'create', '--title', data.title, '--yes'];
-        if (data.description) {
-            args.push('--description', data.description);
-        }
-        if (data.assignee) {
-            args.push('--assignee', data.assignee);
-        }
-        if (data.iteration) {
-            args.push('--milestone', data.iteration);
-        }
-        for (const label of data.labels) {
-            args.push('--label', label);
-        }
-        const output = await glabExec(args, this.cwd);
-        // glab issue create prints a URL like: https://gitlab.com/group/project/-/issues/42
-        const match = output.match(/\/issues\/(\d+)/);
-        if (!match) {
-            throw new Error('Failed to parse issue IID from glab output');
-        }
-        const iid = match[1];
-        return this.getWorkItem(`issue-${iid}`);
+    cacheGid(localId, gid) {
+        this.gidCache.set(localId, gid);
     }
-    async createEpic(data) {
-        if (data.labels.length > 0) {
-            await this.ensureLabels(data.labels);
-        }
-        const encodedGroup = encodeURIComponent(this.group);
-        const args = [
-            'api',
-            `groups/${encodedGroup}/epics`,
-            '-X',
-            'POST',
-            '-f',
-            `title=${data.title}`,
-        ];
-        if (data.description) {
-            args.push('-f', `description=${data.description}`);
-        }
-        for (const label of data.labels) {
-            args.push('-f', `labels[]=${label}`);
-        }
-        const epic = await glab(args, this.cwd);
-        return mapEpicToWorkItem(epic);
-    }
-    async updateIssue(iid, data) {
-        if (data.labels !== undefined && data.labels.length > 0) {
-            await this.ensureLabels(data.labels);
-        }
-        // Handle status changes via close/reopen
-        if (data.status === 'closed') {
-            await glabExec(['issue', 'close', iid], this.cwd);
-        }
-        else if (data.status === 'open') {
-            await glabExec(['issue', 'reopen', iid], this.cwd);
+    async resolveGid(id) {
+        const cached = this.gidCache.get(id);
+        if (cached)
+            return cached;
+        const { type, iid } = parseId(id);
+        if (type === 'issue') {
+            const data = await this.api.graphql(LOOKUP_PROJECT_ITEM, { fullPath: this.remote.fullPath, iid });
+            const node = data.project.workItems.nodes[0];
+            if (!node)
+                throw new Error(`Work item not found: ${id}`);
+            this.cacheGid(id, node.id);
+            return node.id;
+        }
+        const data = await this.api.graphql(LOOKUP_GROUP_ITEM, {
+            fullPath: this.remote.group,
+            iid,
+        });
+        const node = data.group.workItems.nodes[0];
+        if (!node)
+            throw new Error(`Work item not found: ${id}`);
+        this.cacheGid(id, node.id);
+        return node.id;
+    }
+    buildWidgetUpdates(data) {
+        const updates = [];
+        if (data.description !== undefined) {
+            updates.push({
+                descriptionWidget: { description: data.description },
+            });
         }
-        // Handle field edits
-        const editArgs = ['issue', 'update', iid];
-        let hasEdits = false;
-        if (data.title !== undefined) {
-            editArgs.push('--title', data.title);
-            hasEdits = true;
+        if (data.assignee !== undefined) {
+            if (data.assignee) {
+                updates.push({
+                    assigneesWidget: {
+                        assigneeIds: [],
+                        usernames: [data.assignee],
+                    },
+                });
+            }
+            else {
+                updates.push({ assigneesWidget: { assigneeIds: [] } });
+            }
         }
-        if (data.description !== undefined) {
-            editArgs.push('--description', data.description);
-            hasEdits = true;
+        if (data.labels !== undefined) {
+            updates.push({
+                labelsWidget: { setLabelTitles: data.labels },
+            });
         }
         if (data.iteration !== undefined) {
             if (data.iteration) {
-                editArgs.push('--milestone', data.iteration);
+                updates.push({
+                    milestoneWidget: { milestoneTitle: data.iteration },
+                });
             }
             else {
-                editArgs.push('--unlabel', '');
+                updates.push({ milestoneWidget: { milestoneId: null } });
             }
-            hasEdits = true;
         }
-        if (data.assignee !== undefined) {
-            if (data.assignee) {
-                editArgs.push('--assignee', data.assignee);
+        if (data.parent !== undefined) {
+            if (data.parent) {
+                updates.push({ hierarchyWidget: { parentId: data.parent } });
+            }
+            else {
+                updates.push({ hierarchyWidget: { parentId: null } });
             }
-            hasEdits = true;
         }
-        if (data.labels !== undefined) {
-            for (const label of data.labels) {
-                editArgs.push('--label', label);
+        return updates;
+    }
+    async applyUpdate(gid, widgetUpdates, status, title) {
+        const input = { id: gid };
+        if (title !== undefined)
+            input['title'] = title;
+        if (status !== undefined) {
+            input['stateEvent'] = status === 'closed' ? 'CLOSE' : 'REOPEN';
+        }
+        for (const update of widgetUpdates) {
+            for (const [key, value] of Object.entries(update)) {
+                if (key === 'hierarchyWidget' && value && typeof value === 'object') {
+                    const hv = value;
+                    if (hv.parentId &&
+                        typeof hv.parentId === 'string' &&
+                        !hv.parentId.startsWith('gid://')) {
+                        const parentGid = await this.resolveGid(hv.parentId);
+                        input[key] = { parentId: parentGid };
+                    }
+                    else {
+                        input[key] = value;
+                    }
+                }
+                else {
+                    input[key] = value;
+                }
             }
-            hasEdits = true;
         }
-        if (hasEdits) {
-            await glabExec(editArgs, this.cwd);
+        const res = await this.api.graphql(UPDATE_WORK_ITEM, {
+            input,
+        });
+        if (res.workItemUpdate.errors.length > 0) {
+            throw new Error(`Failed to update work item: ${res.workItemUpdate.errors.join(', ')}`);
         }
-        return this.getWorkItem(`issue-${iid}`);
+        const updated = res.workItemUpdate.workItem;
+        const item = mapWorkItemToWorkItem(updated);
+        this.cacheGid(item.id, updated.id);
+        return item;
     }
-    async updateEpic(iid, data) {
-        if (data.labels !== undefined && data.labels.length > 0) {
-            await this.ensureLabels(data.labels);
-        }
-        const encodedGroup = encodeURIComponent(this.group);
-        const args = ['api', `groups/${encodedGroup}/epics/${iid}`, '-X', 'PUT'];
-        let hasEdits = false;
-        if (data.title !== undefined) {
-            args.push('-f', `title=${data.title}`);
-            hasEdits = true;
-        }
-        if (data.description !== undefined) {
-            args.push('-f', `description=${data.description}`);
-            hasEdits = true;
-        }
-        if (data.status !== undefined) {
-            const stateEvent = data.status === 'closed' ? 'close' : 'reopen';
-            args.push('-f', `state_event=${stateEvent}`);
-            hasEdits = true;
-        }
-        if (data.labels !== undefined) {
-            args.push('-f', `labels=${data.labels.join(',')}`);
-            hasEdits = true;
-        }
-        if (hasEdits) {
-            await glab(args, this.cwd);
+    async fetchMilestones() {
+        if (this.cachedMilestones)
+            return this.cachedMilestones;
+        const ms = [];
+        for await (const page of this.api.paginate(PROJECT_MILESTONES, { fullPath: this.remote.fullPath }, (d) => d.project.milestones)) {
+            ms.push(...page);
         }
-        return this.getWorkItem(`epic-${iid}`);
+        this.cachedMilestones = ms;
+        return ms;
     }
 }
 //# sourceMappingURL=index.js.map