@dabble/linear-cli 1.1.0 → 1.1.1

package/README.md

@@ -50,9 +50,11 @@ linear whoami             # Show current user and team
 
 ### Issues
 ```bash
+linear issues                        # Default: backlog + todo
 linear issues --unblocked           # Ready to work on
 linear issues --open                # All non-completed issues
-linear issues --in-progress         # Issues in progress
+linear issues --status in-progress  # Filter by status
+linear issues --status todo --status in-progress  # Multiple statuses
 linear issues --mine                # Only your issues
 linear issues --label bug           # Filter by label
 linear issue show ISSUE-1            # Full details with parent context

package/bin/linear.mjs

@@ -288,6 +288,14 @@ function parseArgs(args, flags = {}) {
       const flagDef = flags[key];
       if (flagDef === 'boolean') {
         result[key] = true;
+      } else if (flagDef === 'array') {
+        const value = args[++i];
+        if (value === undefined || value.startsWith('-')) {
+          console.error(colors.red(`Error: --${key} requires a value`));
+          process.exit(1);
+        }
+        result[key] = result[key] || [];
+        result[key].push(value);
       } else {
         const value = args[++i];
         if (value === undefined || value.startsWith('-')) {
@@ -313,28 +321,42 @@ async function cmdIssues(args) {
     unblocked: 'boolean', u: 'boolean',
     all: 'boolean', a: 'boolean',
     open: 'boolean', o: 'boolean',
-    backlog: 'boolean', b: 'boolean',
     mine: 'boolean', m: 'boolean',
-    'in-progress': 'boolean',
+    status: 'array', s: 'array',
     project: 'string', p: 'string',
     milestone: 'string',
-    state: 'string', s: 'string',
-    label: 'string', l: 'string',
+    label: 'array', l: 'array',
     priority: 'string',
   });
 
-  const inProgress = opts['in-progress'];
   const unblocked = opts.unblocked || opts.u;
   const allStates = opts.all || opts.a;
   const openOnly = opts.open || opts.o;
-  const backlogOnly = opts.backlog || opts.b;
   const mineOnly = opts.mine || opts.m;
+  const statusFilter = opts.status || opts.s || [];
   const projectFilter = opts.project || opts.p;
   const milestoneFilter = opts.milestone;
-  const stateFilter = opts.state || opts.s;
-  const labelFilter = opts.label || opts.l;
+  const labelFilters = opts.label || opts.l || [];
   const priorityFilter = (opts.priority || '').toLowerCase();
 
+  // Map user-friendly status names to Linear's internal state types
+  const STATUS_TYPE_MAP = {
+    'backlog': 'backlog',
+    'todo': 'unstarted',
+    'in-progress': 'started',
+    'inprogress': 'started',
+    'in_progress': 'started',
+    'started': 'started',
+    'done': 'completed',
+    'completed': 'completed',
+    'canceled': 'canceled',
+    'cancelled': 'canceled',
+    'triage': 'triage',
+  };
+
+  // Resolve status filters to state types (match by type map or by state name)
+  const resolvedStatusTypes = statusFilter.map(s => STATUS_TYPE_MAP[s.toLowerCase()] || s.toLowerCase());
+
   // Get current user ID for filtering/sorting
   const viewerResult = await gql('{ viewer { id } }');
   const viewerId = viewerResult.data?.viewer?.id;
@@ -411,9 +433,9 @@ async function cmdIssues(args) {
     if (mineOnly) {
       filtered = filtered.filter(i => i.assignee?.id === viewerId);
     }
-    if (labelFilter) {
+    if (labelFilters.length > 0) {
       filtered = filtered.filter(i =>
-        i.labels?.nodes?.some(l => l.name.toLowerCase() === labelFilter.toLowerCase())
+        labelFilters.some(lf => i.labels?.nodes?.some(l => l.name.toLowerCase() === lf.toLowerCase()))
       );
     }
     if (projectFilter) {
@@ -437,6 +459,13 @@ async function cmdIssues(args) {
     return filtered;
   };
 
+  // Apply status filter to issues
+  const filterByStatus = (list, types) => {
+    return list.filter(i =>
+      types.includes(i.state.type) || types.includes(i.state.name.toLowerCase())
+    );
+  };
+
   if (unblocked) {
     // Collect all blocked issue IDs
     const blocked = new Set();
@@ -453,48 +482,48 @@ async function cmdIssues(args) {
       !['completed', 'canceled'].includes(i.state.type) &&
       !blocked.has(i.identifier)
     );
+    if (resolvedStatusTypes.length > 0) {
+      filtered = filterByStatus(filtered, resolvedStatusTypes);
+    }
 
     filtered = applyFilters(filtered);
 
     console.log(colors.bold('Unblocked Issues:\n'));
     console.log(formatTable(filtered.map(formatRow)));
   } else if (allStates) {
-    let filtered = applyFilters(issues);
+    let filtered = issues;
+    if (resolvedStatusTypes.length > 0) {
+      filtered = filterByStatus(filtered, resolvedStatusTypes);
+    }
+    filtered = applyFilters(filtered);
 
     console.log(colors.bold('All Issues:\n'));
     console.log(formatTable(filtered.map(formatRow)));
   } else if (openOnly) {
-    // Open = everything except completed/canceled
     let filtered = issues.filter(i =>
       !['completed', 'canceled'].includes(i.state.type)
     );
+    if (resolvedStatusTypes.length > 0) {
+      filtered = filterByStatus(filtered, resolvedStatusTypes);
+    }
 
     filtered = applyFilters(filtered);
 
     console.log(colors.bold('Open Issues:\n'));
     console.log(formatTable(filtered.map(formatRow)));
-  } else if (inProgress) {
-    let filtered = issues.filter(i => i.state.type === 'started');
+  } else if (resolvedStatusTypes.length > 0) {
+    let filtered = filterByStatus(issues, resolvedStatusTypes);
     filtered = applyFilters(filtered);
 
-    console.log(colors.bold('In Progress:\n'));
-    console.log(formatTable(filtered.map(formatRow)));
-  } else if (backlogOnly || stateFilter) {
-    const targetState = stateFilter || 'backlog';
-    let filtered = issues.filter(i =>
-      i.state.type === targetState || i.state.name.toLowerCase() === targetState.toLowerCase()
-    );
-
-    filtered = applyFilters(filtered);
-
-    console.log(colors.bold(`Issues (${targetState}):\n`));
+    const label = statusFilter.join(' + ');
+    console.log(colors.bold(`Issues (${label}):\n`));
     console.log(formatTable(filtered.map(formatRow)));
   } else {
-    // Default: show backlog
-    let filtered = issues.filter(i => i.state.type === 'backlog');
+    // Default: show backlog + todo
+    let filtered = issues.filter(i => i.state.type === 'backlog' || i.state.type === 'unstarted');
     filtered = applyFilters(filtered);
 
-    console.log(colors.bold('Issues (backlog):\n'));
+    console.log(colors.bold('Issues (backlog + todo):\n'));
     console.log(formatTable(filtered.map(formatRow)));
   }
 }
@@ -674,13 +703,13 @@ async function cmdIssueCreate(args) {
     project: 'string', p: 'string',
     milestone: 'string',
     parent: 'string',
-    state: 'string', s: 'string',
+    status: 'string', s: 'string',
     assign: 'boolean',
     estimate: 'string', e: 'string',
     priority: 'string',
-    label: 'string', l: 'string',
-    blocks: 'string',
-    'blocked-by': 'string',
+    label: 'array', l: 'array',
+    blocks: 'array',
+    'blocked-by': 'array',
   });
 
   const title = opts.title || opts.t || opts._[0];
@@ -691,9 +720,9 @@ async function cmdIssueCreate(args) {
   const parent = opts.parent;
   const shouldAssign = opts.assign;
   const estimate = (opts.estimate || opts.e || '').toLowerCase();
-  const labelName = opts.label || opts.l;
-  const blocksIssue = opts.blocks;
-  const blockedByIssue = opts['blocked-by'];
+  const labelNames = opts.label || opts.l || [];
+  const blocksIssues = opts.blocks || [];
+  const blockedByIssues = opts['blocked-by'] || [];
 
   if (!title) {
     console.error(colors.red('Error: Title is required'));
@@ -765,20 +794,22 @@ async function cmdIssueCreate(args) {
     }
   }
 
-  // Look up label ID
+  // Look up label IDs
   let labelIds = [];
-  if (labelName) {
+  if (labelNames.length > 0) {
     const labelsResult = await gql(`{
       team(id: "${TEAM_KEY}") {
         labels(first: 100) { nodes { id name } }
       }
     }`);
     const labels = labelsResult.data?.team?.labels?.nodes || [];
-    const match = labels.find(l => l.name.toLowerCase() === labelName.toLowerCase());
-    if (match) {
-      labelIds.push(match.id);
-    } else {
-      console.error(colors.yellow(`Warning: Label "${labelName}" not found. Creating issue without label.`));
+    for (const labelName of labelNames) {
+      const match = labels.find(l => l.name.toLowerCase() === labelName.toLowerCase());
+      if (match) {
+        labelIds.push(match.id);
+      } else {
+        console.error(colors.yellow(`Warning: Label "${labelName}" not found.`));
+      }
     }
   }
 
@@ -817,27 +848,25 @@ async function cmdIssueCreate(args) {
     console.log(issue.url);
 
     // Create blocking relations if specified
-    if (blocksIssue || blockedByIssue) {
+    if (blocksIssues.length > 0 || blockedByIssues.length > 0) {
       const relationMutation = `
         mutation($input: IssueRelationCreateInput!) {
           issueRelationCreate(input: $input) { success }
         }
       `;
 
-      if (blocksIssue) {
-        // This issue blocks another issue
+      for (const target of blocksIssues) {
         await gql(relationMutation, {
-          input: { issueId: issue.identifier, relatedIssueId: blocksIssue, type: 'blocks' }
+          input: { issueId: issue.identifier, relatedIssueId: target, type: 'blocks' }
         });
-        console.log(colors.gray(`  → blocks ${blocksIssue}`));
+        console.log(colors.gray(`  → blocks ${target}`));
       }
 
-      if (blockedByIssue) {
-        // This issue is blocked by another issue
+      for (const target of blockedByIssues) {
         await gql(relationMutation, {
-          input: { issueId: blockedByIssue, relatedIssueId: issue.identifier, type: 'blocks' }
+          input: { issueId: target, relatedIssueId: issue.identifier, type: 'blocks' }
         });
-        console.log(colors.gray(`  → blocked by ${blockedByIssue}`));
+        console.log(colors.gray(`  → blocked by ${target}`));
       }
     }
   } else {
@@ -857,26 +886,52 @@ async function cmdIssueUpdate(args) {
   const opts = parseArgs(args.slice(1), {
     title: 'string', t: 'string',
     description: 'string', d: 'string',
-    state: 'string', s: 'string',
+    status: 'string', s: 'string',
     project: 'string', p: 'string',
     milestone: 'string',
     priority: 'string',
+    estimate: 'string', e: 'string',
+    label: 'array', l: 'array',
+    assign: 'boolean',
+    parent: 'string',
     append: 'string', a: 'string',
     check: 'string',
     uncheck: 'string',
-    blocks: 'string',
-    'blocked-by': 'string',
+    blocks: 'array',
+    'blocked-by': 'array',
   });
 
-  const blocksIssue = opts.blocks;
-  const blockedByIssue = opts['blocked-by'];
+  const blocksIssues = opts.blocks || [];
+  const blockedByIssues = opts['blocked-by'] || [];
   const projectName = resolveAlias(opts.project || opts.p);
   const milestoneName = resolveAlias(opts.milestone);
   const priorityName = (opts.priority || '').toLowerCase();
+  const estimate = (opts.estimate || opts.e || '').toLowerCase();
+  const labelNames = opts.label || opts.l || [];
+  const shouldAssign = opts.assign;
+  const parent = opts.parent;
   const input = {};
 
   if (opts.title || opts.t) input.title = opts.title || opts.t;
 
+  // Handle estimate
+  if (estimate) {
+    if (!ESTIMATE_MAP.hasOwnProperty(estimate)) {
+      console.error(colors.red(`Error: Invalid estimate "${estimate}". Use: XS, S, M, L, or XL`));
+      process.exit(1);
+    }
+    input.estimate = ESTIMATE_MAP[estimate];
+  }
+
+  // Handle parent
+  if (parent) input.parentId = parent;
+
+  // Handle assign
+  if (shouldAssign) {
+    const viewerResult = await gql('{ viewer { id } }');
+    input.assigneeId = viewerResult.data?.viewer?.id;
+  }
+
   // Handle priority
   if (priorityName) {
     if (!PRIORITY_MAP.hasOwnProperty(priorityName)) {
@@ -960,8 +1015,8 @@ async function cmdIssueUpdate(args) {
   }
 
   // Handle state
-  if (opts.state || opts.s) {
-    const stateName = opts.state || opts.s;
+  if (opts.status || opts.s) {
+    const stateName = opts.status || opts.s;
     const statesResult = await gql(`{
       team(id: "${TEAM_KEY}") {
         states { nodes { id name } }
@@ -972,6 +1027,26 @@ async function cmdIssueUpdate(args) {
     if (match) input.stateId = match.id;
   }
 
+  // Handle labels
+  if (labelNames.length > 0) {
+    const labelsResult = await gql(`{
+      team(id: "${TEAM_KEY}") {
+        labels(first: 100) { nodes { id name } }
+      }
+    }`);
+    const labels = labelsResult.data?.team?.labels?.nodes || [];
+    const labelIds = [];
+    for (const labelName of labelNames) {
+      const match = labels.find(l => l.name.toLowerCase() === labelName.toLowerCase());
+      if (match) {
+        labelIds.push(match.id);
+      } else {
+        console.error(colors.yellow(`Warning: Label "${labelName}" not found.`));
+      }
+    }
+    if (labelIds.length > 0) input.labelIds = labelIds;
+  }
+
   // Handle project and milestone
   if (projectName || milestoneName) {
     const projectsResult = await gql(`{
@@ -1013,7 +1088,7 @@ async function cmdIssueUpdate(args) {
   }
 
   // Handle blocking relations (can be set even without other updates)
-  const hasRelationUpdates = blocksIssue || blockedByIssue;
+  const hasRelationUpdates = blocksIssues.length > 0 || blockedByIssues.length > 0;
 
   if (Object.keys(input).length === 0 && !hasRelationUpdates) {
     console.error(colors.red('Error: No updates specified'));
@@ -1052,18 +1127,18 @@ async function cmdIssueUpdate(args) {
       }
     `;
 
-    if (blocksIssue) {
+    for (const target of blocksIssues) {
       await gql(relationMutation, {
-        input: { issueId: issueId, relatedIssueId: blocksIssue, type: 'blocks' }
+        input: { issueId: issueId, relatedIssueId: target, type: 'blocks' }
       });
-      console.log(colors.green(`${issueId} now blocks ${blocksIssue}`));
+      console.log(colors.green(`${issueId} now blocks ${target}`));
     }
 
-    if (blockedByIssue) {
+    for (const target of blockedByIssues) {
       await gql(relationMutation, {
-        input: { issueId: blockedByIssue, relatedIssueId: issueId, type: 'blocks' }
+        input: { issueId: target, relatedIssueId: issueId, type: 'blocks' }
       });
-      console.log(colors.green(`${issueId} now blocked by ${blockedByIssue}`));
+      console.log(colors.green(`${issueId} now blocked by ${target}`));
     }
   }
 }
@@ -2722,7 +2797,6 @@ async function cmdStandup(args) {
 
   const skipGitHub = opts['no-github'];
   const yesterday = getYesterdayDate();
-  const today = getTodayDate();
 
   // Get current user
   const viewerResult = await gql('{ viewer { id name } }');
@@ -2815,93 +2889,88 @@ async function cmdStandup(args) {
     }
   }
 
-  // GitHub activity
+  // GitHub activity (cross-repo)
   if (!skipGitHub) {
     console.log('');
     console.log(colors.gray(`─────────────────────────────────────────\n`));
     console.log(colors.bold('GitHub Activity (yesterday):'));
 
+    let hasActivity = false;
+    let ghAvailable = true;
+
+    // Get commits across all repos
     try {
-      // Get commits from yesterday
-      const sinceDate = `${yesterday}T00:00:00`;
-      const untilDate = `${today}T00:00:00`;
+      const commitsJson = execSync(
+        `gh search commits --author=@me --committer-date=${yesterday} --json sha,commit,repository --limit 50`,
+        { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+      );
+      const commits = JSON.parse(commitsJson);
+
+      if (commits.length > 0) {
+        hasActivity = true;
+        const byRepo = {};
+        for (const c of commits) {
+          const repo = c.repository?.fullName || 'unknown';
+          if (!byRepo[repo]) byRepo[repo] = [];
+          const msg = c.commit?.message?.split('\n')[0] || c.sha.slice(0, 7);
+          byRepo[repo].push(`${c.sha.slice(0, 7)} ${msg}`);
+        }
 
-      // Try to get repo info
-      let repoOwner, repoName;
-      try {
-        const remoteUrl = execSync('git remote get-url origin', { encoding: 'utf-8' }).trim();
-        const match = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
-        if (match) {
-          repoOwner = match[1];
-          repoName = match[2];
+        console.log(`\n  Commits (${commits.length}):`);
+        for (const [repo, repoCommits] of Object.entries(byRepo)) {
+          console.log(`    ${colors.bold(repo)} (${repoCommits.length}):`);
+          for (const commit of repoCommits) {
+            console.log(`      ${commit}`);
+          }
         }
-      } catch (err) {
-        // Not in a git repo or no origin
       }
+    } catch (err) {
+      ghAvailable = false;
+      console.log(colors.gray('  (gh CLI not available - install gh for GitHub activity)'));
+    }
 
-      if (repoOwner && repoName) {
-        // Get git user name for author matching (may differ from Linear display name)
-        let gitUserName;
-        try {
-          gitUserName = execSync('git config user.name', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-        } catch (err) {
-          gitUserName = viewer.name; // Fall back to Linear name
-        }
+    // Get PRs across all repos
+    if (ghAvailable) {
+      try {
+        const mergedJson = execSync(
+          `gh search prs --author=@me --merged-at=${yesterday} --json number,title,repository --limit 20`,
+          { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+        );
+        const mergedPrs = JSON.parse(mergedJson).map(pr => ({ ...pr, prStatus: 'merged' }));
 
-        // Get commits using git log (more reliable than gh for commits)
-        try {
-          const gitLog = execSync(
-            `git log --since="${sinceDate}" --until="${untilDate}" --author="${gitUserName}" --oneline`,
-            { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
-          ).trim();
-
-          if (gitLog) {
-            const commits = gitLog.split('\n').filter(Boolean);
-            console.log(`\n  Commits (${commits.length}):`);
-            for (const commit of commits.slice(0, 10)) {
-              console.log(`    ${commit}`);
-            }
-            if (commits.length > 10) {
-              console.log(colors.gray(`    ... and ${commits.length - 10} more`));
-            }
+        const createdJson = execSync(
+          `gh search prs --author=@me --created=${yesterday} --state=open --json number,title,repository --limit 20`,
+          { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+        );
+        const createdPrs = JSON.parse(createdJson).map(pr => ({ ...pr, prStatus: 'open' }));
+
+        // Deduplicate (a PR created and merged same day appears in both)
+        const seen = new Set();
+        const allPrs = [];
+        for (const pr of [...mergedPrs, ...createdPrs]) {
+          const key = `${pr.repository?.fullName}#${pr.number}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            allPrs.push(pr);
           }
-        } catch (err) {
-          // No commits or git error
         }
 
-        // Get PRs using gh
-        try {
-          const prsJson = execSync(
-            `gh pr list --author @me --state all --json number,title,state,mergedAt,createdAt --limit 20`,
-            { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
-          );
-          const prs = JSON.parse(prsJson);
-
-          // Filter to PRs created or merged yesterday
-          const relevantPrs = prs.filter(pr => {
-            const createdDate = pr.createdAt?.split('T')[0];
-            const mergedDate = pr.mergedAt?.split('T')[0];
-            return createdDate === yesterday || mergedDate === yesterday;
-          });
-
-          if (relevantPrs.length > 0) {
-            console.log(`\n  Pull Requests:`);
-            for (const pr of relevantPrs) {
-              const status = pr.state === 'MERGED' ? colors.green('merged') :
-                            pr.state === 'OPEN' ? colors.yellow('open') :
-                            colors.gray(pr.state.toLowerCase());
-              console.log(`    #${pr.number} ${pr.title} [${status}]`);
-            }
+        if (allPrs.length > 0) {
+          hasActivity = true;
+          console.log(`\n  Pull Requests:`);
+          for (const pr of allPrs) {
+            const repo = pr.repository?.name || '';
+            const status = pr.prStatus === 'merged' ? colors.green('merged') : colors.yellow('open');
+            console.log(`    ${colors.gray(repo + '#')}${pr.number} ${pr.title} [${status}]`);
           }
-        } catch (err) {
-          // gh not available or error
-          console.log(colors.gray('  (gh CLI not available or not authenticated)'));
         }
-      } else {
-        console.log(colors.gray('  (not in a GitHub repository)'));
+      } catch (err) {
+        // gh search error
       }
-    } catch (err) {
-      console.log(colors.gray(`  Error fetching GitHub data: ${err.message}`));
+    }
+
+    if (!hasActivity && ghAvailable) {
+      console.log(colors.gray('  No GitHub activity yesterday'));
     }
   }
 
@@ -3120,17 +3189,15 @@ PLANNING:
     --all, -a                Include completed projects
 
 ISSUES:
-  issues [options]           List issues (default: backlog, yours first)
+  issues [options]           List issues (default: backlog + todo, yours first)
     --unblocked, -u          Show only unblocked issues
     --open, -o               Show all non-completed/canceled issues
-    --backlog, -b            Show only backlog issues
+    --status, -s <name>      Filter by status (repeatable: --status todo --status backlog)
     --all, -a                Show all states (including completed)
     --mine, -m               Show only issues assigned to you
-    --in-progress            Show issues in progress
     --project, -p <name>     Filter by project
     --milestone <name>       Filter by milestone
-    --state, -s <state>      Filter by state
-    --label, -l <name>       Filter by label
+    --label, -l <name>       Filter by label (repeatable)
     --priority <level>       Filter by priority (urgent/high/medium/low/none)
   issues reorder <ids...>    Reorder issues by listing IDs in order
 
@@ -3145,21 +3212,25 @@ ISSUES:
     --assign                 Assign to yourself
     --estimate, -e <size>    Estimate: XS, S, M, L, XL
     --priority <level>       Priority: urgent, high, medium, low, none
-    --label, -l <name>       Add label
-    --blocks <id>            This issue blocks another
-    --blocked-by <id>        This issue is blocked by another
+    --label, -l <name>       Add label (repeatable)
+    --blocks <id>            This issue blocks another (repeatable)
+    --blocked-by <id>        This issue is blocked by another (repeatable)
   issue update <id> [opts]   Update an issue
     --title, -t <title>      New title
     --description, -d <desc> New description
-    --state, -s <state>      New state
+    --status, -s <status>    New status (todo, in-progress, done, backlog, etc.)
     --project, -p <name>     Move to project
     --milestone <name>       Move to milestone
+    --parent <id>            Set parent issue
+    --assign                 Assign to yourself
+    --estimate, -e <size>    Set estimate: XS, S, M, L, XL
     --priority <level>       Set priority (urgent/high/medium/low/none)
+    --label, -l <name>       Set label (repeatable)
     --append, -a <text>      Append to description
     --check <text>           Check a checkbox item (fuzzy match)
     --uncheck <text>         Uncheck a checkbox item (fuzzy match)
-    --blocks <id>            Add blocking relation
-    --blocked-by <id>        Add blocked-by relation
+    --blocks <id>            Add blocking relation (repeatable)
+    --blocked-by <id>        Add blocked-by relation (repeatable)
   issue close <id>           Mark issue as done
   issue comment <id> <body>  Add a comment
   issue move <id>            Move issue in sort order

package/claude/commands/standup.md

@@ -17,8 +17,8 @@ Run `linear standup` to get:
 - Issues currently in progress
 - Issues that are blocked
 
-**From GitHub (if in a repo):**
-- Commits you made yesterday
+**From GitHub (across all repos):**
+- Commits you made yesterday, grouped by repo
 - PRs you opened or merged yesterday
 
 ## After Running
@@ -48,8 +48,9 @@ Here's your standup summary:
 **Blocked:**
 ⊘ ISSUE-12: Waiting on API credentials
 
-**GitHub:**
-- 4 commits on beautiful-tech
+**GitHub (all repos):**
+- dabble/beautiful-tech: 4 commits
+- dabble/linear-cli: 2 commits
 - PR #42 merged: ISSUE-5: Add caching layer
 
 [Presents options above]
@@ -59,5 +60,5 @@ Here's your standup summary:
 
 - The `linear standup` command handles all the data fetching
 - GitHub info requires the `gh` CLI to be installed and authenticated
-- If not in a git repo, GitHub section will be skipped
+- Shows activity across all GitHub repos, not just the current one
 - Use `--no-github` flag to skip GitHub even if available

package/claude/skills/linear-cli/SKILL.md

@@ -84,28 +84,36 @@ linear whoami                   # Show current user/team
 linear roadmap                  # Projects with milestones and progress
 
 # Issues
+linear issues                    # Default: backlog + todo issues
 linear issues --unblocked       # Ready to work on (no blockers)
 linear issues --open            # All non-completed issues
-linear issues --backlog         # Backlog issues only
-linear issues --in-progress     # Issues currently in progress
+linear issues --status todo     # Only todo issues
+linear issues --status backlog  # Only backlog issues
+linear issues --status in-progress # Issues currently in progress
+linear issues --status todo --status in-progress # Multiple statuses
 linear issues --mine            # Only your assigned issues
 linear issues --project "Name"  # Issues in a project
 linear issues --milestone "M1"  # Issues in a milestone
 linear issues --label bug       # Filter by label
 linear issues --priority urgent # Filter by priority (urgent/high/medium/low/none)
-# Flags can be combined: linear issues --in-progress --mine
+# Flags can be combined: linear issues --status todo --mine
 linear issue show ISSUE-1        # Full details with parent context
 linear issue start ISSUE-1       # Assign to you + set In Progress
 linear issue create --title "Fix bug" --project "Phase 1" --assign --estimate M
 linear issue create --title "Urgent bug" --priority urgent --assign
 linear issue create --title "Task" --milestone "Beta" --estimate S
-linear issue create --title "Blocked task" --blocked-by ISSUE-1
-linear issue update ISSUE-1 --state "In Progress"
+linear issue create --title "Blocked task" --blocked-by ISSUE-1 --blocked-by ISSUE-2
+linear issue create --title "Labeled" --label bug --label frontend  # Multiple labels
+linear issue update ISSUE-1 --status "In Progress"
 linear issue update ISSUE-1 --priority high   # Set priority
+linear issue update ISSUE-1 --estimate M      # Set estimate
+linear issue update ISSUE-1 --label bug --label frontend  # Set labels (repeatable)
+linear issue update ISSUE-1 --assign          # Assign to yourself
+linear issue update ISSUE-1 --parent ISSUE-2  # Set parent issue
 linear issue update ISSUE-1 --milestone "Beta"
 linear issue update ISSUE-1 --append "Notes..."
 linear issue update ISSUE-1 --check "validation" # Check off a todo item
-linear issue update ISSUE-1 --blocks ISSUE-2  # Add blocking relation
+linear issue update ISSUE-1 --blocks ISSUE-2 --blocks ISSUE-3  # Repeatable
 linear issue close ISSUE-1
 linear issue comment ISSUE-1 "Comment text"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dabble/linear-cli",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Linear CLI with unblocked issue filtering, built for AI-assisted development",
   "type": "module",
   "bin": {