linear-github-cli 1.0.0

package/dist/commands/commit-first.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commitFirst = commitFirst;
+const child_process_1 = require("child_process");
+const dotenv_1 = require("dotenv");
+const path_1 = require("path");
+const branch_utils_1 = require("../branch-utils");
+const linear_client_1 = require("../linear-client");
+// Load .env file from the project root
+// __dirname points to dist/commands/ in compiled output, so we go up two levels
+(0, dotenv_1.config)({ path: (0, path_1.resolve)(__dirname, '../..', '.env') });
+/**
+ * Creates the first commit with proper message format
+ * - Extracts branch prefix (commit type) and Linear issue ID from current branch name
+ * - Fetches Linear issue title and GitHub issue number
+ * - Generates commit message: "{prefix}: {linearId} {title}" with body "solve: #{githubIssueNumber}"
+ */
+async function commitFirst() {
+    const linearApiKey = process.env.LINEAR_API_KEY;
+    if (!linearApiKey) {
+        console.error('❌ LINEAR_API_KEY environment variable is required');
+        console.error('');
+        console.error('   Option 1: Create a .env file in the project root:');
+        console.error('     echo "LINEAR_API_KEY=lin_api_..." > .env');
+        console.error('');
+        console.error('   Option 2: Export in your shell:');
+        console.error('     export LINEAR_API_KEY="lin_api_..."');
+        console.error('');
+        console.error('   Get your API key from: https://linear.app/settings/api');
+        process.exit(1);
+    }
+    try {
+        // Step 1: Get current branch name
+        let branchName;
+        try {
+            branchName = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+        }
+        catch (error) {
+            console.error('❌ Error: Not in a git repository or unable to get branch name');
+            process.exit(1);
+        }
+        // Step 2: Extract branch prefix and Linear issue ID from branch name
+        const prefix = (0, branch_utils_1.extractBranchPrefix)(branchName);
+        const linearId = (0, branch_utils_1.extractLinearIssueId)(branchName);
+        if (!linearId) {
+            console.error(`❌ Error: Could not extract Linear issue ID from branch name: ${branchName}`);
+            console.error('   Branch name should follow pattern: prefix/LEA-123-title');
+            process.exit(1);
+        }
+        console.log(`📋 Found Linear issue ID: ${linearId}`);
+        console.log(`📋 Using commit type: ${prefix}`);
+        // Step 3: Initialize Linear client and fetch issue data
+        const linearClient = new linear_client_1.LinearClientWrapper(linearApiKey);
+        console.log('🔍 Fetching Linear issue title...');
+        const title = await linearClient.getIssueTitle(linearId);
+        if (!title) {
+            console.error(`❌ Error: Linear issue ${linearId} not found`);
+            process.exit(1);
+        }
+        console.log('🔍 Fetching GitHub issue number...');
+        const githubIssueNumber = await linearClient.getGitHubIssueNumber(linearId);
+        if (!githubIssueNumber) {
+            console.error(`❌ Error: GitHub issue number not found for Linear issue ${linearId}`);
+            console.error('   Make sure the Linear issue is linked to a GitHub issue');
+            process.exit(1);
+        }
+        // Step 4: Generate commit message
+        const commitTitle = `${prefix}: ${linearId} ${title}`;
+        const commitBody = `solve: #${githubIssueNumber}`;
+        console.log('\n📝 Commit message:');
+        console.log(`   ${commitTitle}`);
+        console.log(`   ${commitBody}\n`);
+        // Step 5: Execute commit
+        try {
+            (0, child_process_1.execSync)(`git commit --allow-empty -m "${commitTitle.replace(/"/g, '\\"')}" -m "${commitBody.replace(/"/g, '\\"')}"`, { stdio: 'inherit' });
+            console.log('✅ Commit created successfully!');
+        }
+        catch (error) {
+            console.error('❌ Error: Failed to create commit');
+            console.error(error instanceof Error ? error.message : error);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}

package/dist/commands/create-parent.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParentIssue = createParentIssue;
+const inquirer_1 = __importDefault(require("inquirer"));
+const branch_utils_1 = require("../branch-utils");
+const github_client_1 = require("../github-client");
+const input_handler_1 = require("../input-handler");
+const linear_client_1 = require("../linear-client");
+async function createParentIssue() {
+    const linearApiKey = process.env.LINEAR_API_KEY;
+    if (!linearApiKey) {
+        console.error('❌ LINEAR_API_KEY environment variable is required');
+        console.error('');
+        console.error('   Option 1: Create a .env file in the project root:');
+        console.error('     echo "LINEAR_API_KEY=lin_api_..." > .env');
+        console.error('');
+        console.error('   Option 2: Export in your shell:');
+        console.error('     export LINEAR_API_KEY="lin_api_..."');
+        console.error('');
+        console.error('   Get your API key from: https://linear.app/settings/api');
+        process.exit(1);
+    }
+    const linearClient = new linear_client_1.LinearClientWrapper(linearApiKey);
+    // Step 1: Select repository
+    console.log('📦 Fetching repositories...');
+    const githubClient = new github_client_1.GitHubClientWrapper('');
+    const inputHandler = new input_handler_1.InputHandler(linearClient, githubClient);
+    const repo = await inputHandler.selectRepository();
+    githubClient.repo = repo;
+    // Check for unpushed commits on current branch
+    const unpushedCheck = (0, branch_utils_1.checkUnpushedCommitsOnCurrentBranch)();
+    if (unpushedCheck.hasUnpushed) {
+        console.log('\n⚠️  Warning: There are unpushed commits on the current branch.');
+        console.log(`   Found ${unpushedCheck.count} unpushed commit(s):`);
+        unpushedCheck.commits.forEach(commit => {
+            console.log(`   - ${commit}`);
+        });
+        console.log('\n   If you create a branch from this state, these commits will be included in PR body.');
+        console.log('   Please push commits first:');
+        console.log('     git push');
+        console.log('\n   Then re-run this command.');
+        process.exit(1);
+    }
+    else {
+        console.log('✓ No unpushed commits on current branch');
+    }
+    // Step 2: Get issue details
+    const details = await inputHandler.promptIssueDetails(repo);
+    // Step 3: Select GitHub project (optional)
+    const githubProject = await inputHandler.selectProject(repo);
+    // Step 4: Create GitHub issue
+    console.log('\n🚀 Creating GitHub issue...');
+    const body = details.dueDate
+        ? `Due Date: ${details.dueDate}\n\n${details.description}`
+        : details.description;
+    const issue = await githubClient.createIssue({
+        repo,
+        title: details.title,
+        body,
+        labels: details.labels,
+        assignees: ['@me'],
+        project: githubProject || undefined,
+    });
+    console.log(`✅ GitHub Issue #${issue.number} created: ${issue.url}`);
+    // 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));
+    const linearIssueId = await linearClient.findIssueByGitHubUrl(issue.url);
+    if (linearIssueId) {
+        console.log('✅ Found Linear issue, updating metadata...');
+        // Auto-find Linear project if GitHub project was selected
+        let linearProjectId = null;
+        if (githubProject) {
+            console.log(`   Looking for Linear project matching "${githubProject}"...`);
+            linearProjectId = await linearClient.findProjectByName(githubProject);
+            if (linearProjectId) {
+                console.log(`   ✅ Found matching Linear project: ${githubProject}`);
+            }
+            else {
+                console.log(`   ⚠️  No matching Linear project found. You can set it manually.`);
+            }
+        }
+        // If no auto-match, ask user (only if GitHub project wasn't selected)
+        if (!linearProjectId && !githubProject) {
+            linearProjectId = await inputHandler.selectLinearProject();
+        }
+        // Set labels on Linear issue
+        if (details.labels && details.labels.length > 0) {
+            console.log(`   Setting labels: ${details.labels.join(', ')}`);
+            const labelIds = await linearClient.setIssueLabels(linearIssueId, details.labels);
+            if (labelIds.length > 0) {
+                console.log(`   ✅ ${labelIds.length} label(s) set on Linear issue`);
+            }
+            else {
+                console.log('   ⚠️  Failed to set labels. You can set them manually in Linear.');
+            }
+        }
+        // Update issue metadata (due date and project, but not status)
+        const success = await linearClient.updateIssueMetadata(linearIssueId, details.dueDate || undefined, linearProjectId || undefined);
+        if (success) {
+            console.log('✅ Linear issue metadata updated!');
+            if (linearProjectId) {
+                console.log(`   Project: ${githubProject || 'selected project'}`);
+            }
+            if (details.dueDate) {
+                console.log(`   Due date: ${details.dueDate}`);
+            }
+            console.log('   Status: Will be updated automatically via PR integration');
+        }
+        else {
+            console.log('⚠️  Failed to update Linear issue metadata. You can update it manually in Linear.');
+        }
+        // Step 6: Create branch
+        if (linearIssueId) {
+            const { createBranch } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'createBranch',
+                    message: 'Create git branch for this issue?',
+                    default: true,
+                },
+            ]);
+            if (createBranch) {
+                // Get Linear issue identifier (e.g., LEA-123) instead of UUID
+                const linearIssueIdentifier = await linearClient.getIssueIdentifier(linearIssueId);
+                if (!linearIssueIdentifier) {
+                    console.log('⚠️  Could not get Linear issue identifier. Branch creation skipped.');
+                    console.log(`   Linear issue ID: ${linearIssueId}`);
+                    console.log(`   GitHub issue #${issue.number}`);
+                }
+                else {
+                    const branchPrefix = await (0, branch_utils_1.selectBranchPrefix)(details.labels);
+                    if (branchPrefix) {
+                        const branchName = (0, branch_utils_1.generateBranchName)(branchPrefix, linearIssueIdentifier, details.title);
+                        const success = await (0, branch_utils_1.createGitBranch)(branchName);
+                        if (success) {
+                            console.log(`✅ Branch created: ${branchName}`);
+                            console.log(`   Linear issue ID: ${linearIssueIdentifier}`);
+                            console.log(`   GitHub issue #${issue.number}`);
+                        }
+                    }
+                    else {
+                        console.log('⚠️  No suitable label found for branch prefix. Branch creation skipped.');
+                        console.log(`   Linear issue ID: ${linearIssueIdentifier}`);
+                        console.log(`   GitHub issue #${issue.number}`);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        console.log('⚠️  Linear issue not found yet. Metadata will be set by GitHub Actions.');
+    }
+    console.log('\n💡 Next steps:');
+    console.log(`   Create sub-issues: lg create-sub`);
+    console.log(`   Then select issue #${issue.number}`);
+}

package/dist/commands/create-sub.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSubIssue = createSubIssue;
+const inquirer_1 = __importDefault(require("inquirer"));
+const branch_utils_1 = require("../branch-utils");
+const github_client_1 = require("../github-client");
+const input_handler_1 = require("../input-handler");
+const linear_client_1 = require("../linear-client");
+async function createSubIssue() {
+    const linearApiKey = process.env.LINEAR_API_KEY;
+    if (!linearApiKey) {
+        console.error('❌ LINEAR_API_KEY environment variable is required');
+        console.error('');
+        console.error('   Option 1: Create a .env file in the project root:');
+        console.error('     echo "LINEAR_API_KEY=lin_api_..." > .env');
+        console.error('');
+        console.error('   Option 2: Export in your shell:');
+        console.error('     export LINEAR_API_KEY="lin_api_..."');
+        console.error('');
+        console.error('   Get your API key from: https://linear.app/settings/api');
+        process.exit(1);
+    }
+    const linearClient = new linear_client_1.LinearClientWrapper(linearApiKey);
+    const githubClient = new github_client_1.GitHubClientWrapper('');
+    const inputHandler = new input_handler_1.InputHandler(linearClient, githubClient);
+    // Step 1: Select repository
+    console.log('📦 Fetching repositories...');
+    const repo = await inputHandler.selectRepository();
+    githubClient.repo = repo;
+    // Check for unpushed commits on current branch
+    const unpushedCheck = (0, branch_utils_1.checkUnpushedCommitsOnCurrentBranch)();
+    if (unpushedCheck.hasUnpushed) {
+        console.log('\n⚠️  Warning: There are unpushed commits on the current branch.');
+        console.log(`   Found ${unpushedCheck.count} unpushed commit(s):`);
+        unpushedCheck.commits.forEach(commit => {
+            console.log(`   - ${commit}`);
+        });
+        console.log('\n   If you create a branch from this state, these commits will be included in PR body.');
+        console.log('   Please push commits first:');
+        console.log('     git push');
+        console.log('\n   Then re-run this command.');
+        process.exit(1);
+    }
+    else {
+        console.log('✓ No unpushed commits on current branch');
+    }
+    // Step 2: Select parent issue
+    console.log('\n📋 Fetching issues...');
+    const parentIssueNumber = await inputHandler.selectParentIssue(repo);
+    // Step 3: Get sub-issue details
+    const details = await inputHandler.promptIssueDetails(repo);
+    // Step 4: Create sub-issue
+    console.log('\n🚀 Creating sub-issue...');
+    const body = details.dueDate
+        ? `Due Date: ${details.dueDate}\n\n${details.description}`
+        : details.description;
+    const subIssue = await githubClient.createSubIssue({
+        repo,
+        parentIssueNumber,
+        title: details.title,
+        body,
+        labels: details.labels,
+        assignees: ['@me'],
+    });
+    console.log(`✅ Sub-Issue #${subIssue.number} created: ${subIssue.url}`);
+    console.log(`   Parent: #${parentIssueNumber}`);
+    // 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));
+    const linearIssueId = await linearClient.findIssueByGitHubUrl(subIssue.url);
+    if (linearIssueId) {
+        console.log('✅ Found Linear issue, updating metadata...');
+        // Get parent issue to check if it has a project
+        const parentIssueUrl = `https://github.com/${repo}/issues/${parentIssueNumber}`;
+        console.log(`   Looking for parent issue's Linear project...`);
+        const parentLinearIssueId = await linearClient.findIssueByGitHubUrl(parentIssueUrl);
+        let linearProjectId = null;
+        let parentProjectName = null;
+        if (parentLinearIssueId) {
+            console.log(`   ✅ Found parent Linear issue: ${parentLinearIssueId}`);
+            // Try to get parent issue's project
+            const parentProject = await linearClient.getIssueProject(parentLinearIssueId);
+            if (parentProject) {
+                linearProjectId = parentProject.id;
+                parentProjectName = parentProject.name;
+                console.log(`   ✅ Found parent issue's project: ${parentProjectName}`);
+            }
+            else {
+                console.log(`   ⚠️  Parent issue has no project set`);
+            }
+        }
+        else {
+            console.log(`   ⚠️  Parent Linear issue not found yet (may need more time to sync)`);
+        }
+        // If no parent project, ask user (only if no parent project found)
+        if (!linearProjectId) {
+            linearProjectId = await inputHandler.selectLinearProject();
+        }
+        // Set labels on Linear issue
+        if (details.labels && details.labels.length > 0) {
+            console.log(`   Setting labels: ${details.labels.join(', ')}`);
+            const labelIds = await linearClient.setIssueLabels(linearIssueId, details.labels);
+            if (labelIds.length > 0) {
+                console.log(`   ✅ ${labelIds.length} label(s) set on Linear issue`);
+            }
+            else {
+                console.log('   ⚠️  Failed to set labels. You can set them manually in Linear.');
+            }
+        }
+        // Update issue metadata (due date and project, but not status)
+        const success = await linearClient.updateIssueMetadata(linearIssueId, details.dueDate || undefined, linearProjectId || undefined);
+        if (success) {
+            console.log('✅ Linear issue metadata updated!');
+            if (linearProjectId) {
+                if (parentProjectName) {
+                    console.log(`   Project: ${parentProjectName} (inherited from parent)`);
+                }
+                else {
+                    console.log(`   Project: linked`);
+                }
+            }
+            if (details.dueDate) {
+                console.log(`   Due date: ${details.dueDate}`);
+            }
+            console.log('   Status: Will be updated automatically via PR integration');
+        }
+        else {
+            console.log('⚠️  Failed to update Linear issue metadata. You can update it manually in Linear.');
+        }
+        // Step 6: Create branch
+        if (linearIssueId) {
+            const { createBranch } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'createBranch',
+                    message: 'Create git branch for this issue?',
+                    default: true,
+                },
+            ]);
+            if (createBranch) {
+                // Get Linear issue identifier (e.g., LEA-123) instead of UUID
+                const linearIssueIdentifier = await linearClient.getIssueIdentifier(linearIssueId);
+                if (!linearIssueIdentifier) {
+                    console.log('⚠️  Could not get Linear issue identifier. Branch creation skipped.');
+                    console.log(`   Linear issue ID: ${linearIssueId}`);
+                    console.log(`   GitHub issue #${subIssue.number}`);
+                }
+                else {
+                    const branchPrefix = await (0, branch_utils_1.selectBranchPrefix)(details.labels);
+                    if (branchPrefix) {
+                        const branchName = (0, branch_utils_1.generateBranchName)(branchPrefix, linearIssueIdentifier, details.title);
+                        const success = await (0, branch_utils_1.createGitBranch)(branchName);
+                        if (success) {
+                            console.log(`✅ Branch created: ${branchName}`);
+                            console.log(`   Linear issue ID: ${linearIssueIdentifier}`);
+                            console.log(`   GitHub issue #${subIssue.number}`);
+                        }
+                    }
+                    else {
+                        console.log('⚠️  No suitable label found for branch prefix. Branch creation skipped.');
+                        console.log(`   Linear issue ID: ${linearIssueIdentifier}`);
+                        console.log(`   GitHub issue #${subIssue.number}`);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        console.log('⚠️  Linear issue not found yet. Metadata will be set by GitHub Actions.');
+    }
+}

package/dist/github-client.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubClientWrapper = void 0;
+const rest_1 = require("@octokit/rest");
+const child_process_1 = require("child_process");
+class GitHubClientWrapper {
+    octokit;
+    repo;
+    constructor(repo, token) {
+        this.repo = repo;
+        if (token) {
+            this.octokit = new rest_1.Octokit({ auth: token });
+        }
+    }
+    async getRepositories() {
+        // Use gh CLI to get accessible repos
+        const output = (0, child_process_1.execSync)('gh repo list --limit 100 --json nameWithOwner', {
+            encoding: 'utf-8',
+        });
+        const repos = JSON.parse(output);
+        return repos.map((r) => {
+            const [owner, name] = r.nameWithOwner.split('/');
+            return { owner, name, fullName: r.nameWithOwner };
+        });
+    }
+    async getProjects(repo) {
+        // Extract owner from repo (format: owner/repo)
+        const [owner] = repo.split('/');
+        // Use gh CLI to get projects - note: gh project list uses --owner, not --repo
+        // Output format: {"projects": [...], "totalCount": N}
+        const output = (0, child_process_1.execSync)(`gh project list --owner ${owner} --limit 50 --format json`, { encoding: 'utf-8', stdio: 'pipe' });
+        const result = JSON.parse(output);
+        // Handle both array format and object format
+        const projects = Array.isArray(result) ? result : (result.projects || []);
+        return projects.map((p) => ({
+            id: p.number.toString(),
+            name: p.title,
+        }));
+    }
+    async createIssue(params) {
+        // gh issue create doesn't support --json flag, so we parse the URL from output
+        // Output format: "https://github.com/owner/repo/issues/123"
+        const command = `gh issue create --repo ${params.repo} ` +
+            `--title "${params.title.replace(/"/g, '\\"')}" ` +
+            `--body "${params.body.replace(/"/g, '\\"')}" ` +
+            (params.labels && params.labels.length > 0 ? `--label "${params.labels.join(',')}" ` : '') +
+            (params.assignees && params.assignees.length > 0 ? `--assignee "${params.assignees.join(',')}" ` : '') +
+            (params.project ? `--project "${params.project}" ` : '');
+        const output = (0, child_process_1.execSync)(command, { encoding: 'utf-8' });
+        // Parse URL from output: "https://github.com/owner/repo/issues/123"
+        const urlMatch = output.match(/https:\/\/github\.com\/[^\/]+\/[^\/]+\/issues\/(\d+)/);
+        if (!urlMatch) {
+            throw new Error(`Failed to parse issue URL from output: ${output}`);
+        }
+        const issueNumber = parseInt(urlMatch[1], 10);
+        const issueUrl = urlMatch[0];
+        // Get issue ID using GraphQL API
+        const issueId = await this.getIssueIdByNumber(params.repo, issueNumber);
+        return {
+            number: issueNumber,
+            url: issueUrl,
+            id: issueId,
+        };
+    }
+    async createSubIssue(params) {
+        // First create the issue
+        const issue = await this.createIssue({
+            repo: params.repo,
+            title: params.title,
+            body: params.body,
+            labels: params.labels,
+            assignees: params.assignees,
+        });
+        // Then set parent-child relationship via GraphQL
+        const parentIssue = await this.getIssueById(params.repo, params.parentIssueNumber);
+        (0, child_process_1.execSync)(`gh api graphql -H "GraphQL-Features: sub_issues" -f query="
+        mutation {
+          addSubIssue(input: {
+            issueId: \\\"${parentIssue.id}\\\",
+            subIssueId: \\\"${issue.id}\\\"
+          }) {
+            issue { title }
+            subIssue { title }
+          }
+        }
+      "`, { encoding: 'utf-8' });
+        return issue;
+    }
+    async getIssueIdByNumber(repo, issueNumber) {
+        // Use GraphQL API to get issue ID
+        const [owner, name] = repo.split('/');
+        const query = `query { repository(owner: "${owner}", name: "${name}") { issue(number: ${issueNumber}) { id } } }`;
+        const output = (0, child_process_1.execSync)(`gh api graphql -f query="${query.replace(/"/g, '\\"')}"`, { encoding: 'utf-8' });
+        const result = JSON.parse(output);
+        return result.data.repository.issue.id;
+    }
+    async getIssueById(repo, issueNumber) {
+        const id = await this.getIssueIdByNumber(repo, issueNumber);
+        return { id };
+    }
+    async getLabels(repo) {
+        try {
+            // Use gh CLI to get labels from repository
+            const output = (0, child_process_1.execSync)(`gh label list --repo ${repo} --limit 100 --json name`, { encoding: 'utf-8', stdio: 'pipe' });
+            const labels = JSON.parse(output);
+            return labels.map((l) => l.name).sort();
+        }
+        catch (error) {
+            // Fallback to standard labels if API call fails
+            console.error('⚠️  Failed to fetch labels from GitHub, using default labels');
+            return [
+                'feat',
+                'fix',
+                'chore',
+                'docs',
+                'refactor',
+                'test',
+                'research',
+            ];
+        }
+    }
+}
+exports.GitHubClientWrapper = GitHubClientWrapper;