linear-github-cli 1.0.0

package/dist/input-handler.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputHandler = void 0;
+const child_process_1 = require("child_process");
+const inquirer_1 = __importDefault(require("inquirer"));
+class InputHandler {
+    linearClient;
+    githubClient;
+    constructor(linearClient, githubClient) {
+        this.linearClient = linearClient;
+        this.githubClient = githubClient;
+    }
+    async selectRepository() {
+        const repos = await this.githubClient.getRepositories();
+        const { repo } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'repo',
+                message: 'Select repository:',
+                choices: repos.map(r => ({
+                    name: `${r.fullName}`,
+                    value: r.fullName,
+                })),
+                pageSize: 20,
+            },
+        ]);
+        return repo;
+    }
+    async selectProject(repo) {
+        try {
+            const projects = await this.githubClient.getProjects(repo);
+            if (projects.length === 0) {
+                // No projects available
+                return null;
+            }
+            const { project } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'project',
+                    message: 'Select GitHub Project (or skip):',
+                    choices: [
+                        { name: 'Skip', value: null },
+                        ...projects.map(p => ({ name: p.name, value: p.name })),
+                    ],
+                },
+            ]);
+            return project;
+        }
+        catch (error) {
+            const errorMessage = error.message || error.stderr || String(error);
+            // Check if it's an authentication error
+            if (errorMessage.includes('authentication token') || errorMessage.includes('required scopes')) {
+                console.error('\n❌ GitHub authentication token missing required scopes for projects.');
+                console.error('   Required scope: read:project');
+                console.error('\n   To fix:');
+                console.error('   Run: gh auth refresh -s read:project\n');
+            }
+            else {
+                console.error('\n❌ Failed to fetch GitHub projects.');
+                console.error(`   Error: ${errorMessage}\n`);
+            }
+            // Ask user if they want to proceed without selecting a project
+            const { proceed } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'proceed',
+                    message: 'Do you want to continue without selecting a project?',
+                    default: true,
+                },
+            ]);
+            if (!proceed) {
+                console.log('Cancelled. Please fix the issue and try again.');
+                process.exit(1);
+            }
+            return null;
+        }
+    }
+    async selectLinearProject() {
+        const projects = await this.linearClient.getProjects();
+        if (projects.length === 0) {
+            return null;
+        }
+        const { project } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'project',
+                message: 'Select Linear Project (or skip):',
+                choices: [
+                    { name: 'Skip', value: null },
+                    ...projects.map(p => ({ name: p.name, value: p.id })),
+                ],
+            },
+        ]);
+        return project;
+    }
+    async selectParentIssue(repo) {
+        // Fetch recent issues
+        const output = (0, child_process_1.execSync)(`gh issue list --repo ${repo} --limit 50 --json number,title,state`, { encoding: 'utf-8' });
+        const issues = JSON.parse(output);
+        const { issueNumber } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'issueNumber',
+                message: 'Select parent issue:',
+                choices: issues.map((i) => ({
+                    name: `#${i.number}: ${i.title} [${i.state}]`,
+                    value: i.number,
+                })),
+            },
+        ]);
+        return issueNumber;
+    }
+    async promptIssueDetails(repo) {
+        // Fetch labels from GitHub repository if repo is provided
+        let labelChoices = [];
+        if (repo) {
+            try {
+                console.log('📋 Fetching labels from GitHub...');
+                labelChoices = await this.githubClient.getLabels(repo);
+            }
+            catch (error) {
+                // Fallback to default labels if fetch fails
+                labelChoices = [
+                    'feat',
+                    'fix',
+                    'chore',
+                    'docs',
+                    'refactor',
+                    'test',
+                    'research',
+                ];
+            }
+        }
+        else {
+            // Fallback to default labels if no repo provided
+            labelChoices = [
+                'feat',
+                'fix',
+                'chore',
+                'docs',
+                'refactor',
+                'test',
+                'research',
+            ];
+        }
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'title',
+                message: 'Issue title:',
+                validate: (input) => input.length > 0 || 'Title is required',
+            },
+            {
+                type: 'editor',
+                name: 'description',
+                message: 'Issue description (opens editor):',
+            },
+            {
+                type: 'input',
+                name: 'dueDate',
+                message: 'Due date (YYYY-MM-DD):',
+                validate: (input) => {
+                    if (!input)
+                        return true; // Optional
+                    const date = new Date(input);
+                    return !isNaN(date.getTime()) || 'Invalid date format';
+                },
+            },
+            {
+                type: 'checkbox',
+                name: 'labels',
+                message: 'Select GitHub labels (at least one required):',
+                choices: labelChoices,
+                validate: (input) => {
+                    return input.length > 0 || 'At least one label is required';
+                },
+            },
+        ]);
+        return {
+            title: answers.title,
+            description: answers.description || '',
+            dueDate: answers.dueDate || '',
+            labels: answers.labels || [],
+        };
+    }
+}
+exports.InputHandler = InputHandler;

package/dist/lgcmf.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = require("dotenv");
+const path_1 = require("path");
+const commit_first_1 = require("./commands/commit-first");
+// Load .env file from the project root
+// __dirname points to dist/ in compiled output, so we go up one level
+(0, dotenv_1.config)({ path: (0, path_1.resolve)(__dirname, '..', '.env') });
+(0, commit_first_1.commitFirst)().catch((error) => {
+    console.error('❌ Error:', error instanceof Error ? error.message : error);
+    process.exit(1);
+});

package/dist/linear-client.js

@@ -0,0 +1,433 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinearClientWrapper = void 0;
+const sdk_1 = require("@linear/sdk");
+// Store API key for direct GraphQL calls
+let linearApiKey = '';
+class LinearClientWrapper {
+    client;
+    constructor(apiKey) {
+        linearApiKey = apiKey;
+        this.client = new sdk_1.LinearClient({ apiKey });
+    }
+    async getProjects() {
+        const projects = await this.client.projects();
+        return projects.nodes.map(p => ({ id: p.id, name: p.name }));
+    }
+    async findProjectByName(projectName) {
+        try {
+            const projects = await this.client.projects({
+                filter: { name: { eq: projectName } }
+            });
+            return projects.nodes[0]?.id || null;
+        }
+        catch (error) {
+            // Fallback: get all projects and search manually
+            const allProjects = await this.getProjects();
+            const project = allProjects.find(p => p.name === projectName);
+            return project?.id || null;
+        }
+    }
+    async getWorkflowStates(teamId) {
+        try {
+            // Get workflow states from teams
+            let teamList;
+            if (teamId) {
+                // If a teamId is provided, fetch the single team and wrap in an array
+                const singleTeam = await this.client.team(teamId);
+                teamList = [singleTeam];
+            }
+            else {
+                // Otherwise, fetch all teams and use the nodes property from TeamConnection
+                const teamsConnection = await this.client.teams();
+                teamList = teamsConnection.nodes;
+            }
+            if (!teamList || teamList.length === 0) {
+                return [];
+            }
+            // Get workflow states from the first team
+            const team = Array.isArray(teamList) ? teamList[0] : teamList;
+            if (!team) {
+                return [];
+            }
+            // Use GraphQL to get workflow states
+            const query = `query GetWorkflowStates($teamId: String!) {
+        team(id: $teamId) {
+          states {
+            nodes {
+              id
+              name
+              type
+            }
+          }
+        }
+      }`;
+            const teamIdValue = typeof team === 'object' && 'id' in team ? team.id : teamId || '';
+            const response = await fetch('https://api.linear.app/graphql', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': linearApiKey,
+                },
+                body: JSON.stringify({
+                    query,
+                    variables: { teamId: teamIdValue },
+                }),
+            });
+            const result = await response.json();
+            if (result.errors || !result.data?.team?.states) {
+                return [];
+            }
+            return result.data.team.states.nodes.map((s) => ({
+                id: s.id,
+                name: s.name,
+                type: s.type,
+            }));
+        }
+        catch (error) {
+            console.error('Error fetching workflow states:', error);
+            return [];
+        }
+    }
+    async findOrCreateLabel(teamId, labelName) {
+        try {
+            // First, try to find existing label
+            const labels = await this.getLabels(teamId);
+            const existingLabel = labels.find(l => l.name.toLowerCase() === labelName.toLowerCase());
+            if (existingLabel) {
+                return existingLabel.id;
+            }
+            // If not found, create a new label
+            const mutation = `mutation CreateLabel($teamId: String!, $name: String!) {
+        issueLabelCreate(input: {
+          teamId: $teamId
+          name: $name
+        }) {
+          success
+          issueLabel { id }
+        }
+      }`;
+            const response = await fetch('https://api.linear.app/graphql', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': linearApiKey,
+                },
+                body: JSON.stringify({
+                    query: mutation,
+                    variables: { teamId, name: labelName },
+                }),
+            });
+            const result = await response.json();
+            if (result.errors || !result.data?.issueLabelCreate?.success) {
+                console.error(`❌ Failed to create label "${labelName}":`, result.errors);
+                return null;
+            }
+            return result.data.issueLabelCreate.issueLabel.id;
+        }
+        catch (error) {
+            console.error(`❌ Error finding/creating label "${labelName}":`, error);
+            return null;
+        }
+    }
+    async getIssueTeamId(issueId) {
+        try {
+            const issue = await this.client.issue(issueId);
+            const team = await issue.team;
+            return team?.id || null;
+        }
+        catch (error) {
+            console.error('❌ Error getting issue team:', error);
+            return null;
+        }
+    }
+    async getIssueProjectId(issueId) {
+        try {
+            const issue = await this.client.issue(issueId);
+            const project = await issue.project;
+            return project?.id || null;
+        }
+        catch (error) {
+            // Silently fail - project might not be set
+            return null;
+        }
+    }
+    async getIssueProject(issueId) {
+        try {
+            const issue = await this.client.issue(issueId);
+            const project = await issue.project;
+            if (project) {
+                const name = await project.name;
+                return { id: project.id, name };
+            }
+            return null;
+        }
+        catch (error) {
+            // Silently fail - project might not be set
+            return null;
+        }
+    }
+    async getTeams() {
+        const teams = await this.client.teams();
+        return teams.nodes.map(t => ({ id: t.id, name: t.name, key: t.key }));
+    }
+    async getLabels(teamId) {
+        const team = await this.client.team(teamId);
+        const labels = await team?.labels();
+        return labels?.nodes.map(l => ({ id: l.id, name: l.name })) || [];
+    }
+    async findIssueByGitHubUrl(githubUrl) {
+        const issues = await this.client.issues({
+            filter: {
+                attachments: { url: { contains: githubUrl } }
+            }
+        });
+        return issues.nodes[0]?.id || null;
+    }
+    async getIssueIdentifier(issueId) {
+        try {
+            const issue = await this.client.issue(issueId);
+            if (!issue) {
+                return null;
+            }
+            const identifier = await issue.identifier;
+            return identifier || null;
+        }
+        catch (error) {
+            console.error('❌ Error getting Linear issue identifier:', error instanceof Error ? error.message : error);
+            return null;
+        }
+    }
+    /**
+     * Finds Linear issue by identifier (e.g., 'LEA-123') and returns its ID
+     * Uses GraphQL query to find issue by identifier
+     * @param identifier - Linear issue identifier (e.g., 'LEA-123')
+     * @returns Linear issue ID or null if not found
+     */
+    async findIssueByIdentifier(identifier) {
+        try {
+            // Extract team key and number from identifier (e.g., 'LEA-123' -> team: 'LEA', number: 123)
+            const match = identifier.match(/([A-Z]+)-(\d+)/);
+            if (!match) {
+                return null;
+            }
+            const teamKey = match[1];
+            const issueNumber = parseInt(match[2], 10);
+            // Get team ID first
+            const teamQuery = `query GetTeam($key: String!) {
+        teams(filter: { key: { eq: $key } }) {
+          nodes {
+            id
+          }
+        }
+      }`;
+            const teamResponse = await fetch('https://api.linear.app/graphql', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': linearApiKey,
+                },
+                body: JSON.stringify({
+                    query: teamQuery,
+                    variables: { key: teamKey },
+                }),
+            });
+            const teamResult = await teamResponse.json();
+            if (teamResult.errors || !teamResult.data?.teams?.nodes?.length) {
+                console.error(`❌ Team '${teamKey}' not found`);
+                return null;
+            }
+            const teamId = teamResult.data.teams.nodes[0].id;
+            // Now query issue by team ID and number
+            const issueQuery = `query GetIssue($teamId: ID!, $number: Float!) {
+        issues(
+          filter: {
+            team: { id: { eq: $teamId } }
+            number: { eq: $number }
+          }
+        ) {
+          nodes {
+            id
+          }
+        }
+      }`;
+            const issueResponse = await fetch('https://api.linear.app/graphql', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': linearApiKey,
+                },
+                body: JSON.stringify({
+                    query: issueQuery,
+                    variables: { teamId, number: issueNumber },
+                }),
+            });
+            const issueResult = await issueResponse.json();
+            if (issueResult.errors) {
+                console.error('❌ Linear GraphQL errors:', JSON.stringify(issueResult.errors, null, 2));
+                return null;
+            }
+            if (!issueResult.data?.issues?.nodes?.length) {
+                console.error(`❌ Issue ${identifier} not found`);
+                return null;
+            }
+            return issueResult.data.issues.nodes[0].id || null;
+        }
+        catch (error) {
+            console.error('❌ Error finding Linear issue by identifier:', error instanceof Error ? error.message : error);
+            return null;
+        }
+    }
+    /**
+     * Gets Linear issue title by identifier (e.g., 'LEA-123')
+     * @param identifier - Linear issue identifier (e.g., 'LEA-123')
+     * @returns Issue title or null if not found
+     */
+    async getIssueTitle(identifier) {
+        try {
+            const issueId = await this.findIssueByIdentifier(identifier);
+            if (!issueId) {
+                // Error message already logged in findIssueByIdentifier
+                return null;
+            }
+            const issue = await this.client.issue(issueId);
+            if (!issue) {
+                console.error(`❌ Linear issue ${identifier} (ID: ${issueId}) not found after lookup`);
+                return null;
+            }
+            const title = await issue.title;
+            if (!title) {
+                console.error(`❌ Linear issue ${identifier} has no title`);
+                return null;
+            }
+            return title;
+        }
+        catch (error) {
+            console.error('❌ Error getting Linear issue title:', error instanceof Error ? error.message : error);
+            return null;
+        }
+    }
+    /**
+     * Gets GitHub issue number from Linear issue attachments
+     * Linear SDK/APIにはGitHub issue番号を直接取得する専用フィールドはないため、
+     * attachmentsからGitHub issue URLを取得してパースする必要がある
+     * @param identifier - Linear issue identifier (e.g., 'LEA-123')
+     * @returns GitHub issue number or null if not found
+     */
+    async getGitHubIssueNumber(identifier) {
+        try {
+            const issueId = await this.findIssueByIdentifier(identifier);
+            if (!issueId) {
+                return null;
+            }
+            const issue = await this.client.issue(issueId);
+            if (!issue) {
+                return null;
+            }
+            // Get attachments from the issue
+            const attachments = await issue.attachments();
+            // Look for GitHub issue URL in attachments
+            // Pattern: https://github.com/owner/repo/issues/123
+            const githubIssueUrlPattern = /https:\/\/github\.com\/[^\/]+\/[^\/]+\/issues\/(\d+)/;
+            for (const attachment of attachments.nodes) {
+                const url = await attachment.url;
+                if (url) {
+                    const match = url.match(githubIssueUrlPattern);
+                    if (match && match[1]) {
+                        return parseInt(match[1], 10);
+                    }
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('❌ Error getting GitHub issue number:', error instanceof Error ? error.message : error);
+            return null;
+        }
+    }
+    async updateIssueMetadata(issueId, dueDate, projectId, labelIds) {
+        try {
+            // Get the issue first to verify it exists
+            const issue = await this.client.issue(issueId);
+            if (!issue) {
+                console.error('❌ Linear issue not found');
+                return false;
+            }
+            // Build update input
+            const updateInput = {};
+            if (dueDate) {
+                updateInput.dueDate = new Date(dueDate);
+            }
+            if (projectId) {
+                updateInput.projectId = projectId;
+            }
+            if (labelIds && labelIds.length > 0) {
+                updateInput.labelIds = labelIds;
+            }
+            // Use GraphQL API directly via fetch
+            const mutation = `mutation UpdateIssue($id: String!, $input: IssueUpdateInput!) {
+        issueUpdate(id: $id, input: $input) {
+          success
+          issue { id }
+        }
+      }`;
+            const variables = {
+                id: issueId,
+                input: updateInput,
+            };
+            // Use Linear's GraphQL endpoint directly
+            const response = await fetch('https://api.linear.app/graphql', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': linearApiKey,
+                },
+                body: JSON.stringify({
+                    query: mutation,
+                    variables,
+                }),
+            });
+            const result = await response.json();
+            if (result.errors) {
+                console.error('❌ Linear API error:', result.errors);
+                return false;
+            }
+            return result.data?.issueUpdate?.success || false;
+        }
+        catch (error) {
+            console.error('❌ Error updating Linear issue:', error instanceof Error ? error.message : error);
+            return false;
+        }
+    }
+    async setIssueLabels(issueId, labelNames) {
+        try {
+            // Get team ID from issue
+            const teamId = await this.getIssueTeamId(issueId);
+            if (!teamId) {
+                console.error('❌ Could not determine team for issue');
+                return [];
+            }
+            // Find or create labels and collect their IDs
+            const labelIds = [];
+            for (const labelName of labelNames) {
+                const labelId = await this.findOrCreateLabel(teamId, labelName);
+                if (labelId) {
+                    labelIds.push(labelId);
+                }
+            }
+            // Update issue with labels
+            if (labelIds.length > 0) {
+                const success = await this.updateIssueMetadata(issueId, undefined, undefined, labelIds);
+                if (success) {
+                    return labelIds;
+                }
+            }
+            return [];
+        }
+        catch (error) {
+            console.error('❌ Error setting issue labels:', error instanceof Error ? error.message : error);
+            return [];
+        }
+    }
+}
+exports.LinearClientWrapper = LinearClientWrapper;

package/dist/validate.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Validation script to check code structure and imports
+ * Run with: tsx validate.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const linear_client_1 = require("./linear-client");
+const github_client_1 = require("./github-client");
+const input_handler_1 = require("./input-handler");
+console.log('✅ All imports successful!');
+// Test class instantiation (without API calls)
+console.log('\n📦 Testing class structure...');
+try {
+    // Test LinearClientWrapper structure
+    const linearClient = new linear_client_1.LinearClientWrapper('test-key');
+    console.log('✅ LinearClientWrapper can be instantiated');
+    // Test GitHubClientWrapper structure
+    const githubClient = new github_client_1.GitHubClientWrapper('test/repo');
+    console.log('✅ GitHubClientWrapper can be instantiated');
+    // Test InputHandler structure
+    const inputHandler = new input_handler_1.InputHandler(linearClient, githubClient);
+    console.log('✅ InputHandler can be instantiated');
+    console.log('\n✅ All classes are properly structured!');
+    console.log('\n📋 Next steps:');
+    console.log('   1. Install dependencies: npm install');
+    console.log('   2. Set LINEAR_API_KEY environment variable');
+    console.log('   3. Authenticate GitHub CLI: gh auth login');
+    console.log('   4. Test with: tsx create-parent-issue.ts');
+}
+catch (error) {
+    console.error('❌ Error:', error);
+    process.exit(1);
+}