linear-ai-build 1.0.0

package/src/index.ts

@@ -0,0 +1,287 @@
+import Anthropic from '@anthropic-ai/sdk';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+// Initialize Anthropic client
+const anthropic = new Anthropic({
+  apiKey: process.env.ANTHROPIC_API_KEY!,
+});
+
+interface Story {
+  title: string;
+  description: string;
+  persona: string;
+  acceptanceCriteria: string[];
+  priority: 'high' | 'medium' | 'low';
+  tasks: Task[];
+}
+
+interface Task {
+  title: string;
+  description: string;
+  effort: number; // 1-5
+  parallel: boolean;
+}
+
+interface PRD {
+  title: string;
+  summary: string;
+  stories: Story[];
+  technicalNotes: string[];
+}
+
+/**
+ * Step 1: Generate PRD from feature description using Claude
+ */
+async function generatePRD(featureDescription: string): Promise<PRD> {
+  console.log('🤔 Generating PRD with Claude...\n');
+  
+  const response = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 4000,
+    messages: [{
+      role: 'user',
+      content: `You are an expert product manager. Create a comprehensive Product Requirements Document (PRD) for the following feature:
+
+FEATURE REQUEST:
+${featureDescription}
+
+Generate a detailed PRD with:
+1. Executive summary
+2. 3-5 user stories following the format: "As a [persona], I want to [action] so that [benefit]"
+3. For each story, include acceptance criteria
+4. Technical notes and considerations
+
+Respond ONLY with valid JSON matching this schema:
+{
+  "title": "Feature Title",
+  "summary": "2-3 sentence executive summary",
+  "stories": [
+    {
+      "title": "Story title",
+      "description": "As a [persona], I want to [action] so that [benefit]",
+      "persona": "User type",
+      "acceptanceCriteria": ["criterion 1", "criterion 2"],
+      "priority": "high|medium|low"
+    }
+  ],
+  "technicalNotes": ["note 1", "note 2"]
+}
+
+Return ONLY the JSON, no markdown formatting or explanation.`
+    }]
+  });
+
+  const content = response.content[0];
+  if (content.type !== 'text') {
+    throw new Error('Unexpected response type');
+  }
+
+  // Parse JSON response
+  const prd: PRD = JSON.parse(content.text);
+  
+  // Save PRD to file
+  const prdsDir = path.join(process.cwd(), '.linear', 'prds');
+  await fs.mkdir(prdsDir, { recursive: true });
+  const filename = `${prd.title.toLowerCase().replace(/\s+/g, '-')}-${Date.now()}.json`;
+  await fs.writeFile(
+    path.join(prdsDir, filename),
+    JSON.stringify(prd, null, 2)
+  );
+  
+  console.log(`✅ PRD generated and saved to .linear/prds/${filename}\n`);
+  return prd;
+}
+
+/**
+ * Step 2: Break down each story into tasks using Claude
+ */
+async function generateTasks(story: Story): Promise<Task[]> {
+  console.log(`  🔨 Breaking down: ${story.title}...`);
+  
+  const response = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 2000,
+    messages: [{
+      role: 'user',
+      content: `Break down this user story into concrete development tasks:
+
+STORY: ${story.title}
+DESCRIPTION: ${story.description}
+ACCEPTANCE CRITERIA:
+${story.acceptanceCriteria.map((ac, i) => `${i + 1}. ${ac}`).join('\n')}
+
+Create 3-7 specific tasks covering:
+- Frontend/UI work
+- Backend/API work
+- Database changes (if needed)
+- Testing requirements
+
+For each task provide:
+- Clear title (verb-object format like "Create login form" or "Implement JWT authentication")
+- Description with technical details
+- Effort estimate (1=small, 3=medium, 5=large)
+- Whether it can run in parallel with other tasks
+
+Respond ONLY with valid JSON array:
+[
+  {
+    "title": "Task title",
+    "description": "Technical details of what needs to be done",
+    "effort": 1-5,
+    "parallel": true|false
+  }
+]
+
+Return ONLY the JSON array, no markdown or explanation.`
+    }]
+  });
+
+  const content = response.content[0];
+  if (content.type !== 'text') {
+    throw new Error('Unexpected response type');
+  }
+
+  const tasks: Task[] = JSON.parse(content.text);
+  console.log(`    ✓ Generated ${tasks.length} tasks`);
+  return tasks;
+}
+
+/**
+ * Step 3: Create issues in Linear using MCP tools
+ */
+async function createInLinear(prd: PRD, teamId: string, projectName?: string): Promise<string> {
+  console.log('\n📝 Creating issues in Linear via MCP...\n');
+  
+  // Build the tool use request for Claude
+  const toolMessages: Anthropic.MessageParam[] = [
+    {
+      role: 'user',
+      content: `You have access to Linear through MCP tools. Create a project and issues for this PRD:
+
+PROJECT NAME: ${projectName || prd.title}
+TEAM ID: ${teamId}
+
+PRD DATA:
+${JSON.stringify(prd, null, 2)}
+
+INSTRUCTIONS:
+1. First, search for existing projects with name "${projectName || prd.title}" to avoid duplicates
+2. If project doesn't exist, create it with the PRD summary as description
+3. For each story in the PRD:
+   - Create a parent issue with the story title and description
+   - Add label "user-story" if available
+   - Set priority based on the story's priority field
+4. For each task within a story:
+   - Create a child issue linked to the parent story
+   - Include effort estimate in the description
+   - Add label "task" if available
+
+After creating all issues, provide a summary with:
+- Project URL
+- Number of stories created
+- Number of tasks created
+- Any issues encountered
+
+Use Linear MCP tools to accomplish this.`
+    }
+  ];
+
+  const response = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 8000,
+    messages: toolMessages,
+    tools: [
+      {
+        type: 'mcp',
+        name: 'linear',
+        mcp_server_name: 'linear'
+      } as any
+    ]
+  });
+
+  // Process the response (Claude will have used Linear MCP tools)
+  let finalResponse = '';
+  for (const block of response.content) {
+    if (block.type === 'text') {
+      finalResponse += block.text;
+    }
+  }
+
+  console.log('\n✅ Linear issues created!\n');
+  return finalResponse;
+}
+
+/**
+ * Main workflow
+ */
+async function main() {
+  const args = process.argv.slice(2);
+  
+  if (args.length === 0) {
+    console.log(`
+Usage: npm start -- "Feature description" [teamId] [projectName]
+
+Example:
+  npm start -- "Add user authentication with social login" "TEAM-123" "Auth Epic"
+
+Environment variables required:
+  ANTHROPIC_API_KEY=sk-ant-...
+  LINEAR_API_KEY=lin_api_...  (for MCP server)
+`);
+    process.exit(1);
+  }
+
+  const featureDescription = args[0];
+  const teamId = args[1] || process.env.LINEAR_TEAM_ID;
+  const projectName = args[2];
+
+  if (!teamId) {
+    console.error('❌ Error: Team ID required (provide as argument or LINEAR_TEAM_ID env var)');
+    process.exit(1);
+  }
+
+  try {
+    // Step 1: Generate PRD
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('  STEP 1: Generate PRD');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+    const prd = await generatePRD(featureDescription);
+    
+    console.log(`📋 PRD Summary:`);
+    console.log(`   Title: ${prd.title}`);
+    console.log(`   Stories: ${prd.stories.length}`);
+    console.log('');
+
+    // Step 2: Generate tasks for each story
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('  STEP 2: Generate Tasks');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+    
+    for (const story of prd.stories) {
+      story.tasks = await generateTasks(story);
+    }
+
+    const totalTasks = prd.stories.reduce((sum, s) => sum + s.tasks.length, 0);
+    console.log(`\n✅ Generated ${totalTasks} total tasks across ${prd.stories.length} stories\n`);
+
+    // Step 3: Create in Linear
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('  STEP 3: Create in Linear');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    
+    const summary = await createInLinear(prd, teamId, projectName);
+    console.log(summary);
+
+  } catch (error) {
+    console.error('❌ Error:', error);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+export { generatePRD, generateTasks, createInLinear };