hub-launch 1.0.3

package/dist/services/github/ProjectService.js

@@ -0,0 +1,804 @@
+import { ghGraphQL, getRepoInfo, runGh } from '../../utils/github-cli.js';
+import { logger } from '../../utils/logger.js';
+import { STATUS } from '../../types/common.schema.js';
+import { DeploymentDetectionService } from './DeploymentDetectionService.js';
+/**
+ * Service for GitHub Projects V2 operations
+ * Single Responsibility: GitHub Projects integration
+ */
+export class ProjectService {
+    fieldsCache = new Map();
+    /**
+     * Ensure GitHub CLI has project scope
+     */
+    async ensureProjectScope() {
+        logger.info('Checking GitHub CLI project scope...');
+        try {
+            // Check current scopes
+            const status = await runGh(['auth', 'status'], { silent: true });
+            if (status.includes('project')) {
+                logger.success('Project scope already configured');
+                return true;
+            }
+            logger.warning('Project scope not found. Adding...');
+            // Add project scope with hostname to avoid interactive prompt
+            await runGh([
+                'auth',
+                'refresh',
+                '-s',
+                'project',
+                '--hostname',
+                'github.com',
+            ]);
+            logger.success('Project scope added successfully');
+            return true;
+        }
+        catch (error) {
+            logger.error('Failed to add project scope');
+            logger.error(error instanceof Error ? error.message : String(error));
+            return false;
+        }
+    }
+    /**
+     * Find existing HubLaunch project
+     */
+    async findExistingProject(owner) {
+        logger.info("Searching for existing 'HubLaunch Issue Tracking' project...");
+        try {
+            const result = await runGh([
+                'project',
+                'list',
+                '--owner',
+                owner,
+                '--format',
+                'json',
+            ]);
+            const projects = JSON.parse(result);
+            const project = projects.projects.find((p) => p.title === 'HubLaunch Issue Tracking');
+            if (project) {
+                logger.success(`Found existing project: #${project.number}`);
+                return project.number;
+            }
+            return null;
+        }
+        catch (error) {
+            logger.error('Could not list projects');
+            logger.debug(error instanceof Error ? error.message : String(error));
+            return null;
+        }
+    }
+    /**
+     * Create new HubLaunch project
+     */
+    async createProject(owner) {
+        logger.info("Creating new 'HubLaunch Issue Tracking' project...");
+        try {
+            const result = await runGh([
+                'project',
+                'create',
+                '--owner',
+                owner,
+                '--title',
+                'HubLaunch Issue Tracking',
+                '--format',
+                'json',
+            ]);
+            const data = JSON.parse(result);
+            if (!data.number) {
+                throw new Error('Could not extract project number from response');
+            }
+            logger.success(`Created project: #${data.number}`);
+            return data.number;
+        }
+        catch (error) {
+            logger.error('Failed to create project');
+            throw error;
+        }
+    }
+    /**
+     * Get or create project
+     */
+    async getOrCreateProject(owner) {
+        // First check if project exists
+        const existingProject = await this.findExistingProject(owner);
+        if (existingProject !== null) {
+            return existingProject;
+        }
+        // Create new project
+        return this.createProject(owner);
+    }
+    /**
+     * Get project global ID
+     */
+    async getProjectId(owner, projectNumber) {
+        const query = `
+      query($owner: String!, $number: Int!) {
+        organization(login: $owner) {
+          projectV2(number: $number) {
+            id
+          }
+        }
+      }
+    `;
+        try {
+            const result = await ghGraphQL(query, { owner, number: projectNumber }, { suppressErrors: true });
+            // Check if organization query returned data
+            if (result.data.organization?.projectV2?.id) {
+                return result.data.organization.projectV2.id;
+            }
+            // Organization query returned null, try user query
+            throw new Error('Organization not found or project not accessible');
+        }
+        catch (error) {
+            // Try user query if organization fails
+            logger.debug(`Organization query failed, trying user query for ${owner}`);
+            const userQuery = `
+        query($owner: String!, $number: Int!) {
+          user(login: $owner) {
+            projectV2(number: $number) {
+              id
+            }
+          }
+        }
+      `;
+            try {
+                const userResult = await ghGraphQL(userQuery, { owner, number: projectNumber }, { suppressErrors: true });
+                if (userResult.data.user?.projectV2?.id) {
+                    return userResult.data.user.projectV2.id;
+                }
+                throw new Error('User project not found or not accessible');
+            }
+            catch (userError) {
+                logger.debug(`Both organization and user queries failed for ${owner}/#${projectNumber}`);
+                throw new Error(`Could not find project #${projectNumber} for owner "${owner}". Ensure the owner is correct and you have access to the project.`);
+            }
+        }
+    }
+    /**
+     * List project fields (with caching to avoid rate limits)
+     */
+    async listFields(owner, projectNumber) {
+        const cacheKey = `${owner}/${projectNumber}`;
+        // Check cache first
+        if (this.fieldsCache.has(cacheKey)) {
+            logger.debug(`Using cached fields for project ${cacheKey}`);
+            return this.fieldsCache.get(cacheKey);
+        }
+        try {
+            logger.debug(`Fetching fields for project ${cacheKey}`);
+            const result = await runGh([
+                'project',
+                'field-list',
+                projectNumber.toString(),
+                '--owner',
+                owner,
+                '--format',
+                'json',
+            ]);
+            const data = JSON.parse(result);
+            // Cache the result
+            this.fieldsCache.set(cacheKey, data.fields);
+            return data.fields;
+        }
+        catch (error) {
+            logger.error('Could not list project fields');
+            throw error;
+        }
+    }
+    /**
+     * Create a single-select field with options using GraphQL
+     */
+    async createSingleSelectField(projectId, fieldName, options) {
+        logger.info(`Creating '${fieldName}' field...`);
+        const mutation = `
+      mutation($projectId: ID!, $name: String!, $dataType: ProjectV2CustomFieldType!, $options: [ProjectV2SingleSelectFieldOptionInput!]!) {
+        createProjectV2Field(
+          input: {
+            projectId: $projectId
+            dataType: $dataType
+            name: $name
+            singleSelectOptions: $options
+          }
+        ) {
+          projectV2Field {
+            ... on ProjectV2SingleSelectField {
+              id
+              name
+              options {
+                id
+                name
+              }
+            }
+          }
+        }
+      }
+    `;
+        try {
+            // Use runCommandWithStdin for complex GraphQL mutations with arrays
+            const variables = {
+                projectId,
+                name: fieldName,
+                dataType: 'SINGLE_SELECT',
+                options: options.map((opt) => ({
+                    name: opt.name,
+                    color: opt.color || 'GRAY',
+                    description: opt.description || '',
+                })),
+            };
+            const payload = JSON.stringify({
+                query: mutation,
+                variables,
+            });
+            // Use runCommandWithStdin to send complex JSON payload
+            const { runCommandWithStdin } = await import('../../utils/shell.js');
+            const result = await runCommandWithStdin('gh api graphql --input -', payload);
+            const parsed = JSON.parse(result);
+            const fieldId = parsed.data.createProjectV2Field.projectV2Field.id;
+            logger.success(`Created '${fieldName}' field with ${options.length} options`);
+            // Clear cache to force refresh
+            this.fieldsCache.clear();
+            return fieldId;
+        }
+        catch (error) {
+            logger.error(`Failed to create '${fieldName}' field`);
+            throw error;
+        }
+    }
+    /**
+     * Ensure single-select field exists with given options
+     */
+    async ensureSingleSelectField(owner, projectNumber, projectId, fieldName, options) {
+        logger.info(`Checking for '${fieldName}' field...`);
+        const fields = await this.listFields(owner, projectNumber);
+        const field = fields.find((f) => f.name === fieldName);
+        if (field) {
+            logger.success(`Found '${fieldName}' field`);
+            return field.id;
+        }
+        // Create the field with options
+        const fieldOptions = options.map((name) => ({ name }));
+        return this.createSingleSelectField(projectId, fieldName, fieldOptions);
+    }
+    /**
+     * Ensure tracking name field exists
+     */
+    async ensureTrackingNameField(owner, projectNumber) {
+        logger.info("Checking for 'Tracking Name' field...");
+        const fields = await this.listFields(owner, projectNumber);
+        const trackingField = fields.find((f) => f.name === 'Tracking Name');
+        if (trackingField) {
+            logger.success("Found 'Tracking Name' field");
+            return trackingField.id;
+        }
+        // Create the field
+        logger.info("Creating 'Tracking Name' field...");
+        try {
+            const result = await runGh([
+                'project',
+                'field-create',
+                projectNumber.toString(),
+                '--owner',
+                owner,
+                '--name',
+                'Tracking Name',
+                '--data-type',
+                'TEXT',
+                '--format',
+                'json',
+            ]);
+            const data = JSON.parse(result);
+            if (!data.id) {
+                throw new Error('Could not extract field ID from response');
+            }
+            logger.success("Created 'Tracking Name' field");
+            return data.id;
+        }
+        catch (error) {
+            logger.error('Failed to create field');
+            throw error;
+        }
+    }
+    /**
+     * Add issue to project
+     */
+    async addIssueToProject(issueNumber, projectNumber, owner) {
+        const repo = await getRepoInfo();
+        const repoOwner = owner ?? repo.owner;
+        const issueUrl = `https://github.com/${repo.owner}/${repo.name}/issues/${issueNumber}`;
+        logger.info(`Adding issue #${issueNumber} to project...`);
+        try {
+            const result = await runGh([
+                'project',
+                'item-add',
+                projectNumber.toString(),
+                '--owner',
+                repoOwner,
+                '--url',
+                issueUrl,
+                '--format',
+                'json',
+            ]);
+            const data = JSON.parse(result);
+            if (!data.id) {
+                throw new Error('Could not extract item ID from response');
+            }
+            logger.success('Added issue to project');
+            return data.id;
+        }
+        catch (error) {
+            logger.warning('Could not add issue to project');
+            throw error;
+        }
+    }
+    /**
+     * Update text field in project item
+     */
+    async updateTextField(projectId, itemId, fieldId, value) {
+        const mutation = `
+      mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $value: String!) {
+        updateProjectV2ItemFieldValue(
+          input: {
+            projectId: $projectId
+            itemId: $itemId
+            fieldId: $fieldId
+            value: {
+              text: $value
+            }
+          }
+        ) {
+          projectV2Item {
+            id
+          }
+        }
+      }
+    `;
+        await ghGraphQL(mutation, {
+            projectId,
+            itemId,
+            fieldId,
+            value,
+        });
+    }
+    /**
+     * Update single-select field in project item
+     */
+    async updateSingleSelectField(projectId, itemId, fieldId, optionId) {
+        const mutation = `
+      mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+        updateProjectV2ItemFieldValue(
+          input: {
+            projectId: $projectId
+            itemId: $itemId
+            fieldId: $fieldId
+            value: {
+              singleSelectOptionId: $optionId
+            }
+          }
+        ) {
+          projectV2Item {
+            id
+          }
+        }
+      }
+    `;
+        await ghGraphQL(mutation, {
+            projectId,
+            itemId,
+            fieldId,
+            optionId,
+        });
+    }
+    /**
+     * Set tracking name for project item
+     */
+    async setTrackingName(issueNumber, trackingName, projectNumber, projectId, owner) {
+        const repo = await getRepoInfo();
+        const repoOwner = owner ?? repo.owner;
+        // Get or create tracking name field
+        const fieldId = await this.ensureTrackingNameField(repoOwner, projectNumber);
+        // Add issue to project (or get existing item)
+        let itemId;
+        try {
+            itemId = await this.addIssueToProject(issueNumber, projectNumber, repoOwner);
+        }
+        catch (error) {
+            logger.warning('Issue may already be in project, continuing...');
+            // If item already exists, we need to find it
+            // For now, rethrow the error
+            throw error;
+        }
+        // Update the tracking name field
+        logger.info('Setting tracking name...');
+        await this.updateTextField(projectId, itemId, fieldId, trackingName);
+        logger.success('Tracking name set successfully');
+    }
+    /**
+     * Remove issue from project
+     */
+    async removeIssueFromProject(itemId, projectNumber, owner) {
+        const repo = await getRepoInfo();
+        const repoOwner = owner ?? repo.owner;
+        logger.info('Removing issue from project...');
+        try {
+            await runGh([
+                'project',
+                'item-delete',
+                projectNumber.toString(),
+                '--owner',
+                repoOwner,
+                '--id',
+                itemId,
+            ]);
+            logger.success('Removed issue from project');
+        }
+        catch (error) {
+            logger.warning('Could not remove issue from project');
+            throw error;
+        }
+    }
+    /**
+     * Get project info
+     */
+    async getProjectInfo(owner, projectNumber) {
+        const query = `
+      query($owner: String!, $number: Int!) {
+        organization(login: $owner) {
+          projectV2(number: $number) {
+            id
+            title
+            url
+          }
+        }
+      }
+    `;
+        try {
+            const result = await ghGraphQL(query, { owner, number: projectNumber }, { suppressErrors: true });
+            return {
+                number: projectNumber,
+                id: result.data.organization.projectV2.id,
+                title: result.data.organization.projectV2.title,
+                url: result.data.organization.projectV2.url,
+            };
+        }
+        catch (error) {
+            // Try user query if organization fails
+            const userQuery = `
+        query($owner: String!, $number: Int!) {
+          user(login: $owner) {
+            projectV2(number: $number) {
+              id
+              title
+              url
+            }
+          }
+        }
+      `;
+            try {
+                const userResult = await ghGraphQL(userQuery, { owner, number: projectNumber }, { suppressErrors: true });
+                return {
+                    number: projectNumber,
+                    id: userResult.data.user.projectV2.id,
+                    title: userResult.data.user.projectV2.title,
+                    url: userResult.data.user.projectV2.url,
+                };
+            }
+            catch (userError) {
+                throw new Error(`Could not find project #${projectNumber} for owner "${owner}"`);
+            }
+        }
+    }
+    /**
+     * Find field by name
+     */
+    async findFieldByName(owner, projectNumber, fieldName) {
+        const fields = await this.listFields(owner, projectNumber);
+        return fields.find((f) => f.name === fieldName) ?? null;
+    }
+    /**
+     * Get option ID for single-select field
+     */
+    async getFieldOptionId(owner, projectNumber, fieldName, optionName) {
+        const field = await this.findFieldByName(owner, projectNumber, fieldName);
+        if (!field?.options) {
+            logger.debug(`[getFieldOptionId] Field ${fieldName} has no options`);
+            return null;
+        }
+        logger.debug(`[getFieldOptionId] Looking for option "${optionName}" in field "${fieldName}"`);
+        logger.debug(`[getFieldOptionId] Available options: ${field.options
+            .map((o) => `"${o.name}"`)
+            .join(', ')}`);
+        const option = field.options.find((o) => o.name === optionName);
+        if (option) {
+            logger.debug(`[getFieldOptionId] Found option "${optionName}" with id: ${option.id}`);
+        }
+        else {
+            logger.debug(`[getFieldOptionId] Option "${optionName}" not found in field "${fieldName}"`);
+        }
+        return option?.id ?? null;
+    }
+    /**
+     * Update status field for an issue in project
+     */
+    async updateIssueStatus(itemId, status, projectId, owner, projectNumber) {
+        const field = await this.findFieldByName(owner, projectNumber, 'trackingStatus');
+        if (!field) {
+            throw new Error('trackingStatus field not found in project');
+        }
+        const optionId = await this.getFieldOptionId(owner, projectNumber, 'trackingStatus', status);
+        if (!optionId) {
+            throw new Error(`Status option "${status}" not found in trackingStatus field`);
+        }
+        await this.updateSingleSelectField(projectId, itemId, field.id, optionId);
+    }
+    /**
+     * Update priority field for an issue in project
+     */
+    async updateIssuePriority(itemId, priority, projectId, owner, projectNumber) {
+        const field = await this.findFieldByName(owner, projectNumber, 'priority');
+        if (!field) {
+            throw new Error('priority field not found in project');
+        }
+        const optionId = await this.getFieldOptionId(owner, projectNumber, 'priority', priority);
+        if (!optionId) {
+            throw new Error(`Priority option "${priority}" not found in priority field`);
+        }
+        await this.updateSingleSelectField(projectId, itemId, field.id, optionId);
+    }
+    /**
+     * Set issue tracking status (OwnerIsTracking or AssigneeIsFollowing)
+     * Determines which field to update based on whether current user is the issue creator
+     */
+    async setIssueTracking(itemId, isTracking, projectId, owner, projectNumber) {
+        logger.debug(`[setIssueTracking] Starting for itemId: ${itemId}, isTracking: ${isTracking}`);
+        // Get the issue to check creator
+        const { ghGraphQL: gql } = await import('../../utils/github-cli.js');
+        // Get current user
+        const userQuery = `
+      query {
+        viewer {
+          login
+        }
+      }
+    `;
+        const userResult = await gql(userQuery, {});
+        const currentUser = userResult.data.viewer.login;
+        logger.debug(`[setIssueTracking] Current user: ${currentUser}`);
+        // Get issue creator from the item
+        const itemQuery = `
+      query($itemId: ID!) {
+        node(id: $itemId) {
+          ... on ProjectV2Item {
+            content {
+              ... on Issue {
+                number
+                author {
+                  login
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+        const itemResult = await gql(itemQuery, { itemId });
+        const issueCreator = itemResult.data.node.content.author.login;
+        const isOwner = issueCreator === currentUser;
+        logger.debug(`[setIssueTracking] Issue creator: ${issueCreator}, isOwner: ${isOwner}`);
+        // Determine which field to update
+        const fieldName = isOwner ? 'OwnerIsTracking' : 'AssigneeIsFollowing';
+        logger.debug(`[setIssueTracking] Will update field: ${fieldName}`);
+        const field = await this.findFieldByName(owner, projectNumber, fieldName);
+        if (!field) {
+            logger.error(`${fieldName} field not found in project`);
+            return;
+        }
+        logger.debug(`[setIssueTracking] Found field: ${fieldName}, id: ${field.id}`);
+        // Get option ID for "true" or "false"
+        const optionValue = isTracking ? 'true' : 'false';
+        const optionId = await this.getFieldOptionId(owner, projectNumber, fieldName, optionValue);
+        if (!optionId) {
+            logger.error(`Option "${optionValue}" not found in ${fieldName} field`);
+            return;
+        }
+        logger.debug(`[setIssueTracking] Found option: ${optionValue}, id: ${optionId}`);
+        await this.updateSingleSelectField(projectId, itemId, field.id, optionId);
+        logger.info(`✓ Set ${fieldName} = ${optionValue} for item ${itemId}`);
+    }
+    /**
+     * Get all issues from project with their fields
+     */
+    async getProjectIssues(owner, projectNumber) {
+        const query = `
+      query($owner: String!, $projectNumber: Int!) {
+        organization(login: $owner) {
+          projectV2(number: $projectNumber) {
+            items(first: 100) {
+              nodes {
+                id
+                content {
+                  ... on Issue {
+                    number
+                    title
+                    state
+                    timelineItems(first: 20, itemTypes: [CROSS_REFERENCED_EVENT]) {
+                      nodes {
+                        ... on CrossReferencedEvent {
+                          source {
+                            ... on PullRequest {
+                              number
+                              url
+                              state
+                              comments(last: 10) {
+                                nodes {
+                                  author {
+                                    login
+                                  }
+                                  body
+                                  createdAt
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+                fieldValues(first: 20) {
+                  nodes {
+                    ... on ProjectV2ItemFieldTextValue {
+                      text
+                      field {
+                        ... on ProjectV2FieldCommon {
+                          name
+                        }
+                      }
+                    }
+                    ... on ProjectV2ItemFieldSingleSelectValue {
+                      name
+                      field {
+                        ... on ProjectV2FieldCommon {
+                          name
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+        try {
+            logger.debug(`Fetching project issues for ${owner}/${projectNumber}`);
+            logger.debug(`Trying organization query first...`);
+            const result = await ghGraphQL(query, { owner, projectNumber }, { suppressErrors: true });
+            logger.debug(`Successfully fetched ${result.data.organization.projectV2.items.nodes.length} items from project`);
+            const issues = result.data.organization.projectV2.items.nodes
+                .filter((item) => item.content?.number)
+                .map((item) => {
+                const fields = item.fieldValues.nodes;
+                const trackingName = fields.find((f) => f.field?.name === 'Tracking Name')?.text ?? '';
+                const status = fields.find((f) => f.field?.name === 'trackingStatus')?.name ??
+                    STATUS.UNASSIGNED;
+                const priority = fields.find((f) => f.field?.name === 'priority')?.name ?? 'Medium';
+                // Check for tracking fields - only 'true' means tracked, undefined = false
+                const ownerField = fields.find((f) => f.field?.name === 'OwnerIsTracking');
+                const assigneeField = fields.find((f) => f.field?.name === 'AssigneeIsFollowing');
+                // Only consider tracked if explicitly set to "true" (case-insensitive)
+                // undefined or any other value = false
+                const ownerIsTracking = ownerField?.name?.toLowerCase() === 'true';
+                const assigneeIsFollowing = assigneeField?.name?.toLowerCase() === 'true';
+                const githubState = item.content.state === 'OPEN' ? 'open' : 'closed';
+                // Find linked PR from timeline events and detect deployment status
+                let prNumber;
+                let prUrl;
+                let deploymentStatus;
+                let deploymentTimestamp;
+                if (item.content.timelineItems?.nodes) {
+                    // Find first PR that references this issue
+                    const prEvent = item.content.timelineItems.nodes.find((node) => node.source?.number && node.source?.url);
+                    if (prEvent?.source) {
+                        prNumber = prEvent.source.number;
+                        prUrl = prEvent.source.url;
+                        // Detect deployment status from PR comments
+                        if (prEvent.source.comments?.nodes) {
+                            const deploymentService = new DeploymentDetectionService();
+                            const comments = prEvent.source.comments.nodes.map((c) => ({
+                                author: c.author.login,
+                                body: c.body,
+                                createdAt: c.createdAt,
+                            }));
+                            const deploymentResult = deploymentService.detectDeploymentStatus(comments);
+                            deploymentStatus = deploymentResult.status;
+                            deploymentTimestamp = deploymentResult.timestamp;
+                        }
+                    }
+                }
+                return {
+                    number: item.content.number,
+                    title: item.content.title,
+                    trackingName,
+                    status,
+                    priority,
+                    itemId: item.id,
+                    githubState,
+                    ownerIsTracking,
+                    assigneeIsFollowing,
+                    prNumber,
+                    prUrl,
+                    deploymentStatus,
+                    deploymentTimestamp,
+                };
+            });
+            return issues;
+        }
+        catch (error) {
+            // Try user query if organization fails
+            logger.debug(`Organization query failed, trying user query...`);
+            logger.debug(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            const userQuery = query.replace('organization', 'user');
+            try {
+                const userResult = await ghGraphQL(userQuery, { owner, projectNumber }, { suppressErrors: true });
+                const issues = userResult.data.user.projectV2.items.nodes
+                    .filter((item) => item.content?.number)
+                    .map((item) => {
+                    const fields = item.fieldValues.nodes;
+                    const trackingName = fields.find((f) => f.field?.name === 'Tracking Name')?.text ?? '';
+                    const status = fields.find((f) => f.field?.name === 'trackingStatus')?.name ??
+                        STATUS.UNASSIGNED;
+                    const priority = fields.find((f) => f.field?.name === 'priority')?.name ??
+                        'Medium';
+                    // Check for tracking fields - only 'true' means tracked, undefined = false
+                    const ownerField = fields.find((f) => f.field?.name === 'OwnerIsTracking');
+                    const assigneeField = fields.find((f) => f.field?.name === 'AssigneeIsFollowing');
+                    // Only consider tracked if explicitly set to "true" (case-insensitive)
+                    const ownerIsTracking = ownerField?.name?.toLowerCase() === 'true';
+                    const assigneeIsFollowing = assigneeField?.name?.toLowerCase() === 'true';
+                    const githubState = item.content.state === 'OPEN' ? 'open' : 'closed';
+                    // Find linked PR from timeline events
+                    let prNumber;
+                    let prUrl;
+                    if (item.content.timelineItems?.nodes) {
+                        // Find first PR that references this issue
+                        const prEvent = item.content.timelineItems.nodes.find((node) => node.source?.number && node.source?.url);
+                        if (prEvent?.source) {
+                            prNumber = prEvent.source.number;
+                            prUrl = prEvent.source.url;
+                        }
+                    }
+                    return {
+                        number: item.content.number,
+                        title: item.content.title,
+                        trackingName,
+                        status,
+                        priority,
+                        itemId: item.id,
+                        githubState,
+                        ownerIsTracking,
+                        assigneeIsFollowing,
+                        prNumber,
+                        prUrl,
+                    };
+                });
+                return issues;
+            }
+            catch (userError) {
+                logger.debug(`Both organization and user queries failed for project #${projectNumber}`);
+                logger.debug(`Original error: ${error instanceof Error ? error.message : String(error)}`);
+                logger.debug(`User error: ${userError instanceof Error ? userError.message : String(userError)}`);
+                throw new Error(`Could not access project #${projectNumber} for owner "${owner}". Ensure the owner name is correct and you have access.`);
+            }
+        }
+    }
+    /**
+     * Find project item by issue number
+     */
+    async findProjectItem(owner, projectNumber, issueNumber) {
+        const issues = await this.getProjectIssues(owner, projectNumber);
+        const issue = issues.find((i) => i.number === issueNumber);
+        return issue?.itemId ?? null;
+    }
+}
+//# sourceMappingURL=ProjectService.js.map