linear-github-cli 1.0.3 → 1.1.2

package/README.md

@@ -180,6 +180,25 @@ Make sure you've set the environment variable:
 export LINEAR_API_KEY="lin_api_..."
 ```
 
+### GitHub Project date fields not being set
+
+If start date or target date fields are not being set in GitHub Projects:
+
+1. **Enable debug mode** to see detailed logs:
+   ```bash
+   DEBUG=true lg parent
+   ```
+
+2. **Check the logs** for:
+   - Whether the project item was found (may require retries due to timing)
+   - Whether the date fields exist in the project
+   - Any GraphQL errors
+
+3. **Common issues**:
+   - The issue may not be indexed in the project yet (the tool will retry automatically)
+   - The project may not have "Target" or "Start" date fields configured
+   - Network or API rate limiting issues
+
 ### "lg: command not found"
 
 If you installed globally, make sure npm's global bin directory is in your PATH:

package/dist/cli.js

@@ -20,7 +20,7 @@ const program = new commander_1.Command();
 program
     .name('lg')
     .description('Linear + GitHub Integration CLI - Create GitHub issues with Linear sync')
-    .version('1.0.3');
+    .version('1.1.0');
 program
     .command('create-parent')
     .alias('parent')

package/dist/commands/create-parent.js

@@ -65,6 +65,11 @@ async function createParentIssue() {
         project: githubProject || undefined,
     });
     console.log(`✅ GitHub Issue #${issue.number} created: ${issue.url}`);
+    // Set GitHub Project date fields if project is selected
+    if (githubProject && (details.dueDate || details.startDate)) {
+        console.log('\n📅 Setting GitHub Project date fields...');
+        await githubClient.setProjectDateFields(repo, githubProject, issue.id, details.dueDate || undefined, details.startDate || undefined);
+    }
     // Step 5: Wait for Linear sync, then update metadata
     console.log('\n⏳ Waiting for Linear sync (5 seconds)...');
     await new Promise(resolve => setTimeout(resolve, 5000));

package/dist/commands/create-sub.js

@@ -67,6 +67,18 @@ async function createSubIssue() {
     });
     console.log(`✅ Sub-Issue #${subIssue.number} created: ${subIssue.url}`);
     console.log(`   Parent: #${parentIssueNumber}`);
+    // Set GitHub Project date fields if dates are provided
+    if (details.dueDate || details.startDate) {
+        console.log('\n📅 Setting GitHub Project date fields...');
+        // sub-issueから直接プロジェクト情報を取得（Auto-add sub-issues to projectが有効な場合）
+        const projectName = await githubClient.getIssueProject(repo, subIssue.id);
+        if (projectName) {
+            await githubClient.setProjectDateFields(repo, projectName, subIssue.id, details.dueDate || undefined, details.startDate || undefined);
+        }
+        else {
+            console.log('   ⚠️  Sub-issue has no GitHub Project. Skipping date field setting.');
+        }
+    }
     // Step 5: Wait for Linear sync, then update metadata
     console.log('\n⏳ Waiting for Linear sync (5 seconds)...');
     await new Promise(resolve => setTimeout(resolve, 5000));

package/dist/github-client.js

@@ -119,5 +119,453 @@ class GitHubClientWrapper {
             ];
         }
     }
+    /**
+     * Get project node ID by project name
+     * Supports both Organization and User accounts
+     */
+    async getProjectNodeId(repo, projectName) {
+        try {
+            const [owner] = repo.split('/');
+            let projects = [];
+            // First try Organization
+            try {
+                const orgQuery = `query {
+          organization(login: "${owner}") {
+            projectsV2(first: 50) {
+              nodes {
+                id
+                title
+              }
+            }
+          }
+        }`;
+                const orgOutput = (0, child_process_1.execSync)(`gh api graphql -f query="${orgQuery.replace(/"/g, '\\"')}"`, { encoding: 'utf-8', stdio: 'pipe' });
+                const orgResult = JSON.parse(orgOutput);
+                if (orgResult.data?.organization) {
+                    projects = orgResult.data.organization.projectsV2?.nodes || [];
+                }
+            }
+            catch (orgError) {
+                // Organization not found or error occurred, will try User below
+            }
+            // If no projects found from Organization, try User
+            if (projects.length === 0) {
+                try {
+                    const userQuery = `query {
+            user(login: "${owner}") {
+              projectsV2(first: 50) {
+                nodes {
+                  id
+                  title
+                }
+              }
+            }
+          }`;
+                    const userOutput = (0, child_process_1.execSync)(`gh api graphql -f query="${userQuery.replace(/"/g, '\\"')}"`, { encoding: 'utf-8', stdio: 'pipe' });
+                    const userResult = JSON.parse(userOutput);
+                    if (userResult.data?.user) {
+                        projects = userResult.data.user.projectsV2?.nodes || [];
+                    }
+                }
+                catch (userError) {
+                    // User not found or error occurred
+                }
+            }
+            const project = projects.find((p) => p.title === projectName);
+            return project?.id || null;
+        }
+        catch (error) {
+            console.error('⚠️  Failed to get project node ID:', error);
+            return null;
+        }
+    }
+    /**
+     * Get project field ID by field name
+     */
+    async getProjectFieldId(projectId, fieldName) {
+        const debug = process.env.DEBUG === 'true';
+        try {
+            const query = `query {
+        node(id: "${projectId}") {
+          ... on ProjectV2 {
+            fields(first: 50) {
+              nodes {
+                ... on ProjectV2FieldCommon {
+                  id
+                  name
+                }
+              }
+            }
+          }
+        }
+      }`;
+            if (debug) {
+                console.log(`   [DEBUG] Looking up field "${fieldName}" in project ${projectId}`);
+            }
+            const output = (0, child_process_1.execSync)(`gh api graphql -f query="${query.replace(/"/g, '\\"')}"`, { encoding: 'utf-8', stdio: 'pipe' });
+            const result = JSON.parse(output);
+            if (debug) {
+                console.log(`   [DEBUG] Fields query response:`, JSON.stringify(result, null, 2));
+            }
+            if (result.errors) {
+                console.error(`   ⚠️  GraphQL errors when fetching fields:`, result.errors);
+                return null;
+            }
+            const fields = result.data?.node?.fields?.nodes || [];
+            const field = fields.find((f) => f.name === fieldName);
+            if (field) {
+                if (debug) {
+                    console.log(`   [DEBUG] Found field "${fieldName}" with ID: ${field.id}`);
+                }
+                return field.id;
+            }
+            else {
+                if (debug) {
+                    const availableFields = fields.map((f) => f.name);
+                    console.log(`   [DEBUG] Field "${fieldName}" not found. Available fields:`, availableFields);
+                }
+                return null;
+            }
+        }
+        catch (error) {
+            const errorMessage = error.message || error.stderr || String(error);
+            console.error(`   ⚠️  Failed to get field ID for "${fieldName}": ${errorMessage}`);
+            if (debug) {
+                console.error(`   [DEBUG] Full error:`, error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Get project item ID by issue ID with retry and pagination support
+     */
+    async getProjectItemId(projectId, issueId, maxRetries = 3) {
+        const debug = process.env.DEBUG === 'true';
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                let cursor = null;
+                let hasNextPage = true;
+                let allItems = [];
+                // Paginate through all items
+                while (hasNextPage) {
+                    const query = cursor
+                        ? `query {
+                node(id: "${projectId}") {
+                  ... on ProjectV2 {
+                    items(first: 100, after: "${cursor}") {
+                      pageInfo {
+                        hasNextPage
+                        endCursor
+                      }
+                      nodes {
+                        id
+                        content {
+                          ... on Issue {
+                            id
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }`
+                        : `query {
+                node(id: "${projectId}") {
+                  ... on ProjectV2 {
+                    items(first: 100) {
+                      pageInfo {
+                        hasNextPage
+                        endCursor
+                      }
+                      nodes {
+                        id
+                        content {
+                          ... on Issue {
+                            id
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }`;
+                    if (debug) {
+                        console.log(`   [DEBUG] Attempt ${attempt}/${maxRetries}: Querying project items${cursor ? ` (cursor: ${cursor})` : ''}`);
+                    }
+                    const output = (0, child_process_1.execSync)(`gh api graphql -f query="${query.replace(/"/g, '\\"')}"`, { encoding: 'utf-8', stdio: 'pipe' });
+                    const result = JSON.parse(output);
+                    if (debug) {
+                        console.log(`   [DEBUG] GraphQL response:`, JSON.stringify(result, null, 2));
+                    }
+                    if (result.errors) {
+                        console.error(`   ⚠️  GraphQL errors on attempt ${attempt}:`, result.errors);
+                        throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);
+                    }
+                    const itemsData = result.data?.node?.items;
+                    if (!itemsData) {
+                        console.error(`   ⚠️  Invalid response structure on attempt ${attempt}`);
+                        if (debug) {
+                            console.error(`   [DEBUG] Full response:`, JSON.stringify(result, null, 2));
+                        }
+                        throw new Error('Invalid response structure');
+                    }
+                    const items = itemsData.nodes || [];
+                    allItems = allItems.concat(items);
+                    hasNextPage = itemsData.pageInfo?.hasNextPage || false;
+                    cursor = itemsData.pageInfo?.endCursor || null;
+                    if (debug) {
+                        console.log(`   [DEBUG] Found ${items.length} items in this page (total: ${allItems.length}), hasNextPage: ${hasNextPage}`);
+                    }
+                }
+                // Search for the item with matching issue ID
+                const item = allItems.find((i) => i.content?.id === issueId);
+                if (item) {
+                    if (attempt > 1) {
+                        console.log(`   ✅ Found project item after ${attempt} attempt(s)`);
+                    }
+                    if (debug) {
+                        console.log(`   [DEBUG] Found item ID: ${item.id} for issue ID: ${issueId}`);
+                    }
+                    return item.id;
+                }
+                // If not found and not last attempt, wait and retry
+                if (attempt < maxRetries) {
+                    const waitTime = attempt * 1000; // 1s, 2s, 3s
+                    console.log(`   ⏳ Project item not found (searched ${allItems.length} items), retrying in ${waitTime}ms... (attempt ${attempt}/${maxRetries})`);
+                    await new Promise(resolve => setTimeout(resolve, waitTime));
+                }
+                else {
+                    console.error(`   ⚠️  Project item not found after ${maxRetries} attempts (searched ${allItems.length} total items)`);
+                    if (debug) {
+                        console.error(`   [DEBUG] Issue ID being searched: ${issueId}`);
+                        console.error(`   [DEBUG] Available issue IDs in project:`, allItems.map((i) => i.content?.id).slice(0, 10));
+                    }
+                }
+            }
+            catch (error) {
+                const errorMessage = error.message || error.stderr || String(error);
+                console.error(`   ⚠️  Failed to get project item ID on attempt ${attempt}/${maxRetries}:`, errorMessage);
+                if (debug) {
+                    console.error(`   [DEBUG] Full error:`, error);
+                }
+                // If not last attempt, wait and retry
+                if (attempt < maxRetries) {
+                    const waitTime = attempt * 1000;
+                    console.log(`   ⏳ Retrying in ${waitTime}ms...`);
+                    await new Promise(resolve => setTimeout(resolve, waitTime));
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Set date field value for a project item
+     */
+    async setProjectItemDateField(projectId, itemId, fieldId, date) {
+        const debug = process.env.DEBUG === 'true';
+        try {
+            const mutation = `mutation {
+        updateProjectV2ItemFieldValue(
+          input: {
+            projectId: "${projectId}"
+            itemId: "${itemId}"
+            fieldId: "${fieldId}"
+            value: {
+              date: "${date}"
+            }
+          }
+        ) {
+          projectV2Item {
+            id
+          }
+        }
+      }`;
+            if (debug) {
+                console.log(`   [DEBUG] Executing mutation:`);
+                console.log(`   [DEBUG]   Project ID: ${projectId}`);
+                console.log(`   [DEBUG]   Item ID: ${itemId}`);
+                console.log(`   [DEBUG]   Field ID: ${fieldId}`);
+                console.log(`   [DEBUG]   Date: ${date}`);
+            }
+            const output = (0, child_process_1.execSync)(`gh api graphql -f query="${mutation.replace(/"/g, '\\"')}"`, { encoding: 'utf-8', stdio: 'pipe' });
+            const result = JSON.parse(output);
+            if (debug) {
+                console.log(`   [DEBUG] Mutation response:`, JSON.stringify(result, null, 2));
+            }
+            if (result.errors) {
+                console.error(`   ⚠️  GraphQL errors:`, result.errors);
+                return false;
+            }
+            const success = !!result.data?.updateProjectV2ItemFieldValue?.projectV2Item;
+            if (!success && debug) {
+                console.error(`   [DEBUG] Mutation returned no projectV2Item in response`);
+            }
+            return success;
+        }
+        catch (error) {
+            const errorMessage = error.message || error.stderr || String(error);
+            console.error(`   ⚠️  Failed to set project date field: ${errorMessage}`);
+            if (debug) {
+                console.error(`   [DEBUG] Full error:`, error);
+                console.error(`   [DEBUG] Stack trace:`, error.stack);
+            }
+            return false;
+        }
+    }
+    /**
+     * Set GitHub Project date fields (Target and Start) for an issue
+     */
+    async setProjectDateFields(repo, projectName, issueId, targetDate, startDate) {
+        const debug = process.env.DEBUG === 'true';
+        try {
+            if (debug) {
+                console.log(`   [DEBUG] Setting project date fields:`);
+                console.log(`   [DEBUG]   Repo: ${repo}`);
+                console.log(`   [DEBUG]   Project: ${projectName}`);
+                console.log(`   [DEBUG]   Issue ID: ${issueId}`);
+                console.log(`   [DEBUG]   Target date: ${targetDate || 'not set'}`);
+                console.log(`   [DEBUG]   Start date: ${startDate || 'not set'}`);
+            }
+            // Get project node ID
+            console.log(`   Looking up project "${projectName}"...`);
+            const projectId = await this.getProjectNodeId(repo, projectName);
+            if (!projectId) {
+                console.error(`   ⚠️  Project "${projectName}" not found`);
+                if (debug) {
+                    console.error(`   [DEBUG] Tried to find project in repo: ${repo}`);
+                }
+                return false;
+            }
+            if (debug) {
+                console.log(`   [DEBUG] Found project ID: ${projectId}`);
+            }
+            // Get project item ID (with retry mechanism)
+            console.log(`   Looking up issue in project...`);
+            const itemId = await this.getProjectItemId(projectId, issueId);
+            if (!itemId) {
+                console.error(`   ⚠️  Issue not found in project "${projectName}"`);
+                console.error(`   ⚠️  This may be due to a timing issue. The issue may appear in the project shortly.`);
+                if (debug) {
+                    console.error(`   [DEBUG] Project ID: ${projectId}`);
+                    console.error(`   [DEBUG] Issue ID: ${issueId}`);
+                }
+                return false;
+            }
+            if (debug) {
+                console.log(`   [DEBUG] Found project item ID: ${itemId}`);
+            }
+            let success = true;
+            const results = {};
+            // Set Target date field if provided
+            if (targetDate) {
+                console.log(`   Setting Target date field...`);
+                const targetFieldId = await this.getProjectFieldId(projectId, 'Target');
+                if (targetFieldId) {
+                    if (debug) {
+                        console.log(`   [DEBUG] Target field ID: ${targetFieldId}`);
+                    }
+                    const result = await this.setProjectItemDateField(projectId, itemId, targetFieldId, targetDate);
+                    results.target = result;
+                    if (result) {
+                        console.log(`   ✅ Set Target date: ${targetDate}`);
+                    }
+                    else {
+                        console.log(`   ⚠️  Failed to set Target date: ${targetDate}`);
+                        if (debug) {
+                            console.error(`   [DEBUG] Mutation may have failed. Check GraphQL response above.`);
+                        }
+                        success = false;
+                    }
+                }
+                else {
+                    console.log(`   ⚠️  Target field not found in project "${projectName}"`);
+                    if (debug) {
+                        console.error(`   [DEBUG] Make sure the project has a "Target" date field configured.`);
+                    }
+                    success = false;
+                }
+            }
+            // Set Start date field if provided
+            if (startDate) {
+                console.log(`   Setting Start date field...`);
+                const startFieldId = await this.getProjectFieldId(projectId, 'Start');
+                if (startFieldId) {
+                    if (debug) {
+                        console.log(`   [DEBUG] Start field ID: ${startFieldId}`);
+                    }
+                    const result = await this.setProjectItemDateField(projectId, itemId, startFieldId, startDate);
+                    results.start = result;
+                    if (result) {
+                        console.log(`   ✅ Set Start date: ${startDate}`);
+                    }
+                    else {
+                        console.log(`   ⚠️  Failed to set Start date: ${startDate}`);
+                        if (debug) {
+                            console.error(`   [DEBUG] Mutation may have failed. Check GraphQL response above.`);
+                        }
+                        success = false;
+                    }
+                }
+                else {
+                    console.log(`   ⚠️  Start field not found in project "${projectName}"`);
+                    if (debug) {
+                        console.error(`   [DEBUG] Make sure the project has a "Start" date field configured.`);
+                    }
+                    success = false;
+                }
+            }
+            // Summary
+            if (debug) {
+                console.log(`   [DEBUG] Date field setting results:`, results);
+            }
+            if (!success) {
+                console.log(`   ⚠️  Some date fields failed to set. Check the messages above for details.`);
+            }
+            return success;
+        }
+        catch (error) {
+            const errorMessage = error.message || error.stderr || String(error);
+            console.error(`   ⚠️  Failed to set project date fields: ${errorMessage}`);
+            if (debug) {
+                console.error(`   [DEBUG] Full error:`, error);
+                console.error(`   [DEBUG] Stack trace:`, error.stack);
+            }
+            return false;
+        }
+    }
+    /**
+     * Get GitHub Project name from issue ID
+     */
+    async getIssueProject(repo, issueId) {
+        try {
+            const [owner, name] = repo.split('/');
+            const query = `query {
+        repository(owner: "${owner}", name: "${name}") {
+          issue(id: "${issueId}") {
+            projectItems(first: 10) {
+              nodes {
+                project {
+                  ... on ProjectV2 {
+                    title
+                  }
+                }
+              }
+            }
+          }
+        }
+      }`;
+            const output = (0, child_process_1.execSync)(`gh api graphql -f query="${query.replace(/"/g, '\\"')}"`, { encoding: 'utf-8', stdio: 'pipe' });
+            const result = JSON.parse(output);
+            const projectItems = result.data?.repository?.issue?.projectItems?.nodes || [];
+            if (projectItems.length > 0) {
+                return projectItems[0].project?.title || null;
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('⚠️  Failed to get issue project:', error);
+            return null;
+        }
+    }
 }
 exports.GitHubClientWrapper = GitHubClientWrapper;

package/dist/input-handler.js

@@ -158,6 +158,17 @@ class InputHandler {
                 name: 'description',
                 message: 'Issue description (opens editor):',
             },
+            {
+                type: 'input',
+                name: 'startDate',
+                message: 'Start date (YYYY-MM-DD, optional):',
+                validate: (input) => {
+                    if (!input)
+                        return true; // Optional
+                    const date = new Date(input);
+                    return !isNaN(date.getTime()) || 'Invalid date format';
+                },
+            },
             {
                 type: 'input',
                 name: 'dueDate',
@@ -183,6 +194,7 @@ class InputHandler {
             title: answers.title,
             description: answers.description || '',
             dueDate: answers.dueDate || '',
+            startDate: answers.startDate || '',
             labels: answers.labels || [],
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linear-github-cli",
-  "version": "1.0.3",
+  "version": "1.1.2",
   "description": "CLI tool for creating GitHub issues with Linear integration",
   "main": "dist/cli.js",
   "bin": {