@dabble/linear-cli 1.1.0 → 1.1.2

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

@@ -12,9 +12,12 @@ import { exec, execSync } from 'child_process';
 
 const API_URL = 'https://api.linear.app/graphql';
 let CONFIG_FILE = '';
+let AUTH_CONFIG_FILE = '';
 let LINEAR_API_KEY = '';
 let TEAM_KEY = '';
 let ALIASES = {};
+let DEFAULT_PROJECT = '';
+let DEFAULT_MILESTONE = '';
 
 // Colors (ANSI)
 const colors = {
@@ -34,16 +37,16 @@ function loadConfig() {
   const localPath = join(process.cwd(), '.linear');
   const globalPath = join(homedir(), '.linear');
 
-  // Priority: ./.linear > ~/.linear > env vars
-  if (existsSync(localPath)) {
-    CONFIG_FILE = localPath;
-  } else if (existsSync(globalPath)) {
-    CONFIG_FILE = globalPath;
-  }
+  // Layer: read global first, then local on top (local values override global)
+  const filesToLoad = [];
+  if (existsSync(globalPath)) filesToLoad.push(globalPath);
+  if (existsSync(localPath)) filesToLoad.push(localPath);
 
-  // Load from config file first (highest priority)
-  if (CONFIG_FILE) {
-    const content = readFileSync(CONFIG_FILE, 'utf-8');
+  // CONFIG_FILE is used for local/project writes (open/close) — always local
+  CONFIG_FILE = localPath;
+
+  for (const filePath of filesToLoad) {
+    const content = readFileSync(filePath, 'utf-8');
     let inAliasSection = false;
 
     for (const line of content.split('\n')) {
@@ -64,11 +67,17 @@ function loadConfig() {
       const value = rest.join('=').trim();
 
       if (inAliasSection) {
-        // Store aliases with uppercase keys
+        // Store aliases with uppercase keys (later files override)
         ALIASES[key.trim().toUpperCase()] = value;
       } else {
-        if (key.trim() === 'api_key') LINEAR_API_KEY = value;
-        if (key.trim() === 'team') TEAM_KEY = value;
+        const k = key.trim();
+        if (k === 'api_key') {
+          LINEAR_API_KEY = value;
+          AUTH_CONFIG_FILE = filePath;
+        }
+        if (k === 'team') TEAM_KEY = value;
+        if (k === 'project') DEFAULT_PROJECT = value;
+        if (k === 'milestone') DEFAULT_MILESTONE = value;
       }
     }
   }
@@ -76,6 +85,8 @@ function loadConfig() {
   // Fall back to env vars if not set by config file
   if (!LINEAR_API_KEY) LINEAR_API_KEY = process.env.LINEAR_API_KEY || '';
   if (!TEAM_KEY) TEAM_KEY = process.env.LINEAR_TEAM || '';
+  if (!DEFAULT_PROJECT) DEFAULT_PROJECT = process.env.LINEAR_PROJECT || '';
+  if (!DEFAULT_MILESTONE) DEFAULT_MILESTONE = process.env.LINEAR_MILESTONE || '';
 }
 
 function resolveAlias(nameOrAlias) {
@@ -83,13 +94,39 @@ function resolveAlias(nameOrAlias) {
   return ALIASES[nameOrAlias.toUpperCase()] || nameOrAlias;
 }
 
-function saveAlias(code, name) {
-  if (!CONFIG_FILE) {
-    console.error(colors.red('Error: No config file found. Run "linear login" first.'));
+async function ensureAuthConfig() {
+  if (AUTH_CONFIG_FILE) return;
+
+  console.log('No config file found. Where should aliases be saved?\n');
+  console.log('  1. This project only (./.linear)');
+  console.log('  2. Global, for all projects (~/.linear)');
+  console.log('');
+
+  const choice = await prompt('Enter number: ');
+  if (choice !== '1' && choice !== '2') {
+    console.error(colors.red('Error: Please enter 1 or 2'));
     process.exit(1);
   }
 
-  const content = readFileSync(CONFIG_FILE, 'utf-8');
+  if (choice === '1') {
+    AUTH_CONFIG_FILE = join(process.cwd(), '.linear');
+    if (!existsSync(AUTH_CONFIG_FILE)) {
+      writeFileSync(AUTH_CONFIG_FILE, '');
+      ensureGitignore();
+    }
+  } else {
+    AUTH_CONFIG_FILE = join(homedir(), '.linear');
+    if (!existsSync(AUTH_CONFIG_FILE)) {
+      writeFileSync(AUTH_CONFIG_FILE, '');
+    }
+  }
+  console.log('');
+}
+
+async function saveAlias(code, name) {
+  await ensureAuthConfig();
+
+  const content = readFileSync(AUTH_CONFIG_FILE, 'utf-8');
   const lines = content.split('\n');
 
   // Find or create [aliases] section
@@ -136,12 +173,12 @@ function saveAlias(code, name) {
     lines.push(aliasLine);
   }
 
-  writeFileSync(CONFIG_FILE, lines.join('\n'));
+  writeFileSync(AUTH_CONFIG_FILE, lines.join('\n'));
   ALIASES[upperCode] = name;
 }
 
-function removeAlias(code) {
-  if (!CONFIG_FILE) {
+async function removeAlias(code) {
+  if (!AUTH_CONFIG_FILE) {
     console.error(colors.red('Error: No config file found.'));
     process.exit(1);
   }
@@ -152,7 +189,7 @@ function removeAlias(code) {
     process.exit(1);
   }
 
-  const content = readFileSync(CONFIG_FILE, 'utf-8');
+  const content = readFileSync(AUTH_CONFIG_FILE, 'utf-8');
   const lines = content.split('\n');
   let inAliasSection = false;
 
@@ -175,10 +212,100 @@ function removeAlias(code) {
     return true;
   });
 
-  writeFileSync(CONFIG_FILE, newLines.join('\n'));
+  writeFileSync(AUTH_CONFIG_FILE, newLines.join('\n'));
   delete ALIASES[upperCode];
 }
 
+function ensureLocalConfig() {
+  // CONFIG_FILE always points to local ./.linear
+  if (existsSync(CONFIG_FILE)) return;
+
+  // Create local config file
+  writeFileSync(CONFIG_FILE, '');
+
+  // Add .linear to .gitignore
+  ensureGitignore();
+}
+
+function ensureGitignore() {
+  const gitignorePath = join(process.cwd(), '.gitignore');
+  try {
+    let gitignore = '';
+    if (existsSync(gitignorePath)) {
+      gitignore = readFileSync(gitignorePath, 'utf-8');
+    }
+
+    const lines = gitignore.split('\n').map(l => l.trim());
+    if (!lines.includes('.linear')) {
+      const newline = gitignore.endsWith('\n') || gitignore === '' ? '' : '\n';
+      writeFileSync(gitignorePath, gitignore + newline + '.linear\n');
+      console.log(colors.green(`Added .linear to .gitignore`));
+    }
+  } catch (err) {
+    // Silently ignore if we can't update .gitignore
+  }
+}
+
+function writeConfigValue(key, value) {
+  ensureLocalConfig();
+
+  const content = readFileSync(CONFIG_FILE, 'utf-8');
+  const lines = content.split('\n');
+  let found = false;
+  let insertBefore = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    // Stop before section headers
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+      if (insertBefore === -1) insertBefore = i;
+      break;
+    }
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const [k] = trimmed.split('=');
+    if (k.trim() === key) {
+      lines[i] = `${key}=${value}`;
+      found = true;
+      break;
+    }
+  }
+
+  if (!found) {
+    const newLine = `${key}=${value}`;
+    if (insertBefore !== -1) {
+      lines.splice(insertBefore, 0, newLine);
+    } else {
+      lines.push(newLine);
+    }
+  }
+
+  writeFileSync(CONFIG_FILE, lines.join('\n'));
+}
+
+function removeConfigValue(key) {
+  if (!existsSync(CONFIG_FILE)) return null;
+
+  const content = readFileSync(CONFIG_FILE, 'utf-8');
+  const lines = content.split('\n');
+  let removed = null;
+
+  const newLines = lines.filter(line => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('[')) return true;
+    const [k, ...rest] = trimmed.split('=');
+    if (k.trim() === key) {
+      removed = rest.join('=').trim();
+      return false;
+    }
+    return true;
+  });
+
+  if (removed !== null) {
+    writeFileSync(CONFIG_FILE, newLines.join('\n'));
+  }
+  return removed;
+}
+
 function checkAuth() {
   if (!LINEAR_API_KEY) {
     console.error(colors.red("Error: Not logged in. Run 'linear login' first."));
@@ -288,6 +415,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 +448,46 @@ 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',
+    'no-project': 'boolean',
+    'no-milestone': 'boolean',
+    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 projectFilter = opts.project || opts.p;
-  const milestoneFilter = opts.milestone;
-  const stateFilter = opts.state || opts.s;
-  const labelFilter = opts.label || opts.l;
+  const statusFilter = opts.status || opts.s || [];
+  const noProject = opts['no-project'];
+  const noMilestone = opts['no-milestone'];
+  const projectFilter = noProject ? '' : (opts.project || opts.p || DEFAULT_PROJECT);
+  const milestoneFilter = noMilestone ? '' : (opts.milestone || DEFAULT_MILESTONE);
+  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;
@@ -386,6 +539,15 @@ async function cmdIssues(args) {
   // Check if any issues have priority set
   const hasPriority = issues.some(i => i.priority > 0);
 
+  // When filtering to a single project, drop the project column
+  const showProjectCol = !projectFilter;
+
+  // Build context string for header (e.g. "[My Project > Sprint 3]")
+  const contextParts = [];
+  if (projectFilter) contextParts.push(resolveAlias(projectFilter));
+  if (milestoneFilter) contextParts.push(resolveAlias(milestoneFilter));
+  const contextStr = contextParts.length > 0 ? ` [${contextParts.join(' > ')}]` : '';
+
   // Helper to format issue row
   const formatRow = (i) => {
     const row = [
@@ -397,7 +559,9 @@ async function cmdIssues(args) {
       const pri = PRIORITY_LABELS[i.priority] || '';
       row.push(pri ? colors.bold(pri) : '-');
     }
-    row.push(i.project?.name || '-');
+    if (showProjectCol) {
+      row.push(i.project?.name || '-');
+    }
     if (hasAssignees) {
       const assignee = i.assignee?.id === viewerId ? 'you' : (i.assignee?.name || '-');
       row.push(assignee);
@@ -411,9 +575,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 +601,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 +624,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(colors.bold(`Unblocked Issues${contextStr}:\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(colors.bold(`All Issues${contextStr}:\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(colors.bold(`Open Issues${contextStr}:\n`));
     console.log(formatTable(filtered.map(formatRow)));
-  } else if (inProgress) {
-    let filtered = issues.filter(i => i.state.type === 'started');
-    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()
-    );
-
+  } else if (resolvedStatusTypes.length > 0) {
+    let filtered = filterByStatus(issues, resolvedStatusTypes);
     filtered = applyFilters(filtered);
 
-    console.log(colors.bold(`Issues (${targetState}):\n`));
+    const label = statusFilter.join(' + ');
+    console.log(colors.bold(`Issues${contextStr} (${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${contextStr} (backlog + todo):\n`));
     console.log(formatTable(filtered.map(formatRow)));
   }
 }
@@ -674,26 +845,26 @@ 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];
   const description = opts.description || opts.d || '';
-  const project = resolveAlias(opts.project || opts.p);
+  const project = resolveAlias(opts.project || opts.p) || DEFAULT_PROJECT;
   const priority = (opts.priority || '').toLowerCase();
-  const milestone = resolveAlias(opts.milestone);
+  const milestone = resolveAlias(opts.milestone) || DEFAULT_MILESTONE;
   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 +936,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 +990,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 +1028,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 +1157,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 +1169,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 +1230,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 +1269,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}`));
     }
   }
 }
@@ -2275,7 +2492,7 @@ async function cmdAlias(args) {
 
   // Remove alias
   if (removeCode) {
-    removeAlias(removeCode);
+    await removeAlias(removeCode);
     console.log(colors.green(`Removed alias: ${removeCode.toUpperCase()}`));
     return;
   }
@@ -2289,7 +2506,7 @@ async function cmdAlias(args) {
     process.exit(1);
   }
 
-  saveAlias(code, name);
+  await saveAlias(code, name);
   console.log(colors.green(`Alias set: ${code.toUpperCase()} -> ${name}`));
 }
 
@@ -2722,7 +2939,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 +3031,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'));
     }
   }
 
@@ -3024,25 +3235,7 @@ team=${selectedKey}
 
   // Add .linear to .gitignore if saving locally
   if (!saveGlobal) {
-    const gitignorePath = join(process.cwd(), '.gitignore');
-    try {
-      let gitignore = '';
-      if (existsSync(gitignorePath)) {
-        gitignore = readFileSync(gitignorePath, 'utf-8');
-      }
-
-      // Check if .linear is already in .gitignore
-      const lines = gitignore.split('\n').map(l => l.trim());
-      if (!lines.includes('.linear')) {
-        // Add .linear to .gitignore
-        const newline = gitignore.endsWith('\n') || gitignore === '' ? '' : '\n';
-        const content = gitignore + newline + '.linear\n';
-        writeFileSync(gitignorePath, content);
-        console.log(colors.green(`Added .linear to .gitignore`));
-      }
-    } catch (err) {
-      // Silently ignore if we can't update .gitignore
-    }
+    ensureGitignore();
 
     // Add .linear to .worktreeinclude for worktree support
     const worktreeIncludePath = join(process.cwd(), '.worktreeinclude');
@@ -3120,17 +3313,17 @@ 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
+    --project, -p <name>     Filter by project (default: open project)
+    --milestone <name>       Filter by milestone (default: open milestone)
+    --no-project             Bypass default project filter
+    --no-milestone           Bypass default milestone filter
+    --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 +3338,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
@@ -3176,6 +3373,8 @@ PROJECTS:
     --name, -n <name>        Project name (required)
     --description, -d <desc> Project description
   project complete <name>    Mark project as completed
+  project open <name>        Set default project for issues/create
+  project close              Clear default project
   project move <name>        Move project in sort order
     --before <name>          Move before this project
     --after <name>           Move after this project
@@ -3193,6 +3392,8 @@ MILESTONES:
     --project, -p <name>     Project (required)
     --description, -d <desc> Milestone description
     --target-date <date>     Target date (YYYY-MM-DD)
+  milestone open <name>      Set default milestone for issues/create
+  milestone close            Clear default milestone
   milestone move <name>      Move milestone in sort order
     --before <name>          Move before this milestone
     --after <name>           Move after this milestone
@@ -3229,17 +3430,27 @@ WORKFLOW:
     lnext() { eval "$(linear next "$@")"; }
 
 CONFIGURATION:
-  Config is loaded from ./.linear first, then ~/.linear, then env vars.
+  Config is layered: ~/.linear (global) then ./.linear (local override).
+  Local values override global; unset local values inherit from global.
+  Env vars (LINEAR_API_KEY, LINEAR_TEAM, LINEAR_PROJECT, LINEAR_MILESTONE)
+  are used as fallbacks when not set in any config file.
 
   File format:
     api_key=lin_api_xxx
     team=ISSUE
+    project=My Project
+    milestone=Sprint 3
 
     [aliases]
     LWW=Last-Write-Wins Support
     MVP=MVP Release
 
 EXAMPLES:
+  linear project open "Phase 1"    # Set default project context
+  linear milestone open "Sprint 3" # Set default milestone context
+  linear issues                    # Filtered to Phase 1 > Sprint 3
+  linear issues --no-project       # Bypass default, show all projects
+  linear project close             # Clear default project
   linear roadmap             # See all projects and milestones
   linear issues --unblocked  # Find workable issues
   linear issues --project "Phase 1"  # Issues in a project
@@ -3322,6 +3533,29 @@ async function main() {
           case 'create': await cmdProjectCreate(subargs); break;
           case 'complete': await cmdProjectComplete(subargs); break;
           case 'move': await cmdProjectMove(subargs); break;
+          case 'open': {
+            const name = resolveAlias(subargs[0]);
+            if (!name) {
+              console.error(colors.red('Error: Project name required'));
+              console.error('Usage: linear project open "Project Name"');
+              process.exit(1);
+            }
+            writeConfigValue('project', name);
+            DEFAULT_PROJECT = name;
+            console.log(colors.green(`Opened project: ${name}`));
+            console.log(colors.gray(`Saved to ${CONFIG_FILE}`));
+            break;
+          }
+          case 'close': {
+            const removed = removeConfigValue('project');
+            if (removed) {
+              console.log(colors.green(`Closed project: ${removed}`));
+              DEFAULT_PROJECT = '';
+            } else {
+              console.log(colors.gray('No project was open'));
+            }
+            break;
+          }
           default:
             console.error(`Unknown project command: ${subcmd}`);
             process.exit(1);
@@ -3346,6 +3580,29 @@ async function main() {
           case 'show': await cmdMilestoneShow(subargs); break;
           case 'create': await cmdMilestoneCreate(subargs); break;
           case 'move': await cmdMilestoneMove(subargs); break;
+          case 'open': {
+            const name = resolveAlias(subargs[0]);
+            if (!name) {
+              console.error(colors.red('Error: Milestone name required'));
+              console.error('Usage: linear milestone open "Milestone Name"');
+              process.exit(1);
+            }
+            writeConfigValue('milestone', name);
+            DEFAULT_MILESTONE = name;
+            console.log(colors.green(`Opened milestone: ${name}`));
+            console.log(colors.gray(`Saved to ${CONFIG_FILE}`));
+            break;
+          }
+          case 'close': {
+            const removed = removeConfigValue('milestone');
+            if (removed) {
+              console.log(colors.green(`Closed milestone: ${removed}`));
+              DEFAULT_MILESTONE = '';
+            } else {
+              console.log(colors.gray('No milestone was open'));
+            }
+            break;
+          }
           default:
             console.error(`Unknown milestone command: ${subcmd}`);
             process.exit(1);

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

@@ -25,12 +25,14 @@ This will:
 
 ## Configuration
 
-Config is loaded in order: `./.linear` → `~/.linear` → env vars
+Config is layered: `~/.linear` (global) is loaded first, then `./.linear` (local) overrides on top. Local values override global; unset local values inherit from global. Env vars (`LINEAR_API_KEY`, `LINEAR_TEAM`, `LINEAR_PROJECT`, `LINEAR_MILESTONE`) are used as fallbacks.
 
 ```
 # .linear file format
 api_key=lin_api_xxx
 team=ISSUE
+project=My Project
+milestone=Sprint 3
 
 [aliases]
 V2=Version 2.0 Release
@@ -83,29 +85,45 @@ linear whoami                   # Show current user/team
 # Roadmap (overview)
 linear roadmap                  # Projects with milestones and progress
 
+# Default context (sets project/milestone for issues & create)
+linear project open "Phase 1"    # Set default project
+linear milestone open "Sprint 3" # Set default milestone
+linear project close             # Clear default project
+linear milestone close           # Clear default milestone
+
 # Issues
+linear issues                    # Default: backlog + todo issues (filtered by open project/milestone)
+linear issues --no-project       # Bypass default project filter
+linear issues --no-milestone     # Bypass default milestone filter
 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"
 
@@ -115,11 +133,15 @@ linear projects --all           # Include completed
 linear project show "Phase 1"   # Details with issues
 linear project create "Name" --description "..."
 linear project complete "Phase 1"
+linear project open "Phase 1"   # Set as default project
+linear project close            # Clear default project
 
 # Milestones
 linear milestones --project "P1" # Milestones in a project
 linear milestone show "Beta"     # Details with issues
 linear milestone create "Beta" --project "P1" --target-date 2024-03-01
+linear milestone open "Beta"    # Set as default milestone
+linear milestone close          # Clear default milestone
 
 # Reordering (drag-drop equivalent)
 linear projects reorder "P1" "P2" "P3"           # Set project order
@@ -182,6 +204,16 @@ gh pr create --title "ISSUE-5: Add caching layer"
 
 ## Workflow Guidelines
 
+### Setting context
+When working on a specific project/milestone, set it as default to avoid repeating flags:
+```bash
+linear project open "Phase 1"    # All commands now default to Phase 1
+linear milestone open "Sprint 3" # And to Sprint 3 milestone
+linear issues                    # Shows Phase 1 > Sprint 3 issues only
+linear issue create --title "Fix" # Created in Phase 1, Sprint 3
+linear project close             # Done? Clear the context
+```
+
 ### Getting oriented
 ```bash
 linear roadmap                  # See all projects, milestones, progress

package/package.json

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