@dabble/linear-cli 1.0.5 → 1.1.1

package/bin/linear.mjs

@@ -14,6 +14,7 @@ const API_URL = 'https://api.linear.app/graphql';
 let CONFIG_FILE = '';
 let LINEAR_API_KEY = '';
 let TEAM_KEY = '';
+let ALIASES = {};
 
 // Colors (ANSI)
 const colors = {
@@ -43,12 +44,32 @@ function loadConfig() {
   // Load from config file first (highest priority)
   if (CONFIG_FILE) {
     const content = readFileSync(CONFIG_FILE, 'utf-8');
+    let inAliasSection = false;
+
     for (const line of content.split('\n')) {
-      if (!line || line.startsWith('#')) continue;
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+
+      // Check for section header
+      if (trimmed === '[aliases]') {
+        inAliasSection = true;
+        continue;
+      }
+      if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        inAliasSection = false;
+        continue;
+      }
+
       const [key, ...rest] = line.split('=');
       const value = rest.join('=').trim();
-      if (key === 'api_key') LINEAR_API_KEY = value;
-      if (key === 'team') TEAM_KEY = value;
+
+      if (inAliasSection) {
+        // Store aliases with uppercase keys
+        ALIASES[key.trim().toUpperCase()] = value;
+      } else {
+        if (key.trim() === 'api_key') LINEAR_API_KEY = value;
+        if (key.trim() === 'team') TEAM_KEY = value;
+      }
     }
   }
 
@@ -57,6 +78,107 @@ function loadConfig() {
   if (!TEAM_KEY) TEAM_KEY = process.env.LINEAR_TEAM || '';
 }
 
+function resolveAlias(nameOrAlias) {
+  if (!nameOrAlias) return 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.'));
+    process.exit(1);
+  }
+
+  const content = readFileSync(CONFIG_FILE, 'utf-8');
+  const lines = content.split('\n');
+
+  // Find or create [aliases] section
+  let aliasStart = -1;
+  let aliasEnd = -1;
+  let existingAliasLine = -1;
+  const upperCode = code.toUpperCase();
+
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed === '[aliases]') {
+      aliasStart = i;
+    } else if (aliasStart !== -1 && aliasEnd === -1) {
+      if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        aliasEnd = i;
+      } else if (trimmed && !trimmed.startsWith('#')) {
+        const [key] = trimmed.split('=');
+        if (key.trim().toUpperCase() === upperCode) {
+          existingAliasLine = i;
+        }
+      }
+    }
+  }
+
+  // If no alias section end found, it goes to EOF
+  if (aliasStart !== -1 && aliasEnd === -1) {
+    aliasEnd = lines.length;
+  }
+
+  const aliasLine = `${upperCode}=${name}`;
+
+  if (existingAliasLine !== -1) {
+    // Update existing alias
+    lines[existingAliasLine] = aliasLine;
+  } else if (aliasStart !== -1) {
+    // Add to existing section
+    lines.splice(aliasStart + 1, 0, aliasLine);
+  } else {
+    // Create new section at end
+    if (lines[lines.length - 1] !== '') {
+      lines.push('');
+    }
+    lines.push('[aliases]');
+    lines.push(aliasLine);
+  }
+
+  writeFileSync(CONFIG_FILE, lines.join('\n'));
+  ALIASES[upperCode] = name;
+}
+
+function removeAlias(code) {
+  if (!CONFIG_FILE) {
+    console.error(colors.red('Error: No config file found.'));
+    process.exit(1);
+  }
+
+  const upperCode = code.toUpperCase();
+  if (!ALIASES[upperCode]) {
+    console.error(colors.red(`Alias not found: ${code}`));
+    process.exit(1);
+  }
+
+  const content = readFileSync(CONFIG_FILE, 'utf-8');
+  const lines = content.split('\n');
+  let inAliasSection = false;
+
+  const newLines = lines.filter(line => {
+    const trimmed = line.trim();
+    if (trimmed === '[aliases]') {
+      inAliasSection = true;
+      return true;
+    }
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+      inAliasSection = false;
+      return true;
+    }
+    if (inAliasSection && trimmed && !trimmed.startsWith('#')) {
+      const [key] = trimmed.split('=');
+      if (key.trim().toUpperCase() === upperCode) {
+        return false;
+      }
+    }
+    return true;
+  });
+
+  writeFileSync(CONFIG_FILE, newLines.join('\n'));
+  delete ALIASES[upperCode];
+}
+
 function checkAuth() {
   if (!LINEAR_API_KEY) {
     console.error(colors.red("Error: Not logged in. Run 'linear login' first."));
@@ -132,16 +254,27 @@ function openBrowser(url) {
   exec(cmd);
 }
 
+// Strip ANSI escape codes for length calculation
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
 function formatTable(rows) {
   if (rows.length === 0) return '';
   const colWidths = [];
   for (const row of rows) {
     row.forEach((cell, i) => {
-      colWidths[i] = Math.max(colWidths[i] || 0, String(cell).length);
+      // Use visible length (without ANSI codes) for width calculation
+      colWidths[i] = Math.max(colWidths[i] || 0, stripAnsi(String(cell)).length);
     });
   }
   return rows.map(row =>
-    row.map((cell, i) => String(cell).padEnd(colWidths[i])).join('  ')
+    row.map((cell, i) => {
+      const str = String(cell);
+      const visibleLen = stripAnsi(str).length;
+      // Pad based on visible length, not string length
+      return str + ' '.repeat(Math.max(0, colWidths[i] - visibleLen));
+    }).join('  ')
   ).join('\n');
 }
 
@@ -155,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('-')) {
@@ -180,25 +321,41 @@ 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 } }');
@@ -234,26 +391,35 @@ async function cmdIssues(args) {
   // Check if any issues have assignees (to decide whether to show column)
   const hasAssignees = issues.some(i => i.assignee);
 
-  // Sort: assigned to you first, then by priority, then by sortOrder
+  // Sort: assigned to you first, then by priority (urgent first), then by sortOrder
   issues.sort((a, b) => {
     const aIsMine = a.assignee?.id === viewerId;
     const bIsMine = b.assignee?.id === viewerId;
     if (aIsMine && !bIsMine) return -1;
     if (!aIsMine && bIsMine) return 1;
-    // Then by priority (higher = more urgent)
-    if ((b.priority || 0) !== (a.priority || 0)) return (b.priority || 0) - (a.priority || 0);
+    // Then by priority (lower number = more urgent, but 0 means no priority so sort last)
+    const aPri = a.priority || 5; // No priority (0) sorts after Low (4)
+    const bPri = b.priority || 5;
+    if (aPri !== bPri) return aPri - bPri;
     // Then by sortOrder
     return (b.sortOrder || 0) - (a.sortOrder || 0);
   });
 
+  // Check if any issues have priority set
+  const hasPriority = issues.some(i => i.priority > 0);
+
   // Helper to format issue row
   const formatRow = (i) => {
     const row = [
       i.identifier,
       i.title,
       i.state.name,
-      i.project?.name || '-'
     ];
+    if (hasPriority) {
+      const pri = PRIORITY_LABELS[i.priority] || '';
+      row.push(pri ? colors.bold(pri) : '-');
+    }
+    row.push(i.project?.name || '-');
     if (hasAssignees) {
       const assignee = i.assignee?.id === viewerId ? 'you' : (i.assignee?.name || '-');
       row.push(assignee);
@@ -267,24 +433,39 @@ 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) {
+      const resolvedProject = resolveAlias(projectFilter);
       filtered = filtered.filter(i =>
-        i.project?.name?.toLowerCase().includes(projectFilter.toLowerCase())
+        i.project?.name?.toLowerCase().includes(resolvedProject.toLowerCase())
       );
     }
     if (milestoneFilter) {
+      const resolvedMilestone = resolveAlias(milestoneFilter);
       filtered = filtered.filter(i =>
-        i.projectMilestone?.name?.toLowerCase().includes(milestoneFilter.toLowerCase())
+        i.projectMilestone?.name?.toLowerCase().includes(resolvedMilestone.toLowerCase())
       );
     }
+    if (priorityFilter) {
+      const targetPriority = PRIORITY_MAP[priorityFilter];
+      if (targetPriority !== undefined) {
+        filtered = filtered.filter(i => i.priority === targetPriority);
+      }
+    }
     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();
@@ -301,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');
-    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 (${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)));
   }
 }
@@ -497,6 +678,24 @@ const ESTIMATE_MAP = {
   'xl': 5,
 };
 
+// Linear priority values (lower number = higher priority)
+// 0 = No priority, 1 = Urgent, 2 = High, 3 = Medium, 4 = Low
+const PRIORITY_LABELS = {
+  0: '',
+  1: 'Urgent',
+  2: 'High',
+  3: 'Medium',
+  4: 'Low',
+};
+
+const PRIORITY_MAP = {
+  'urgent': 1,
+  'high': 2,
+  'medium': 3,
+  'low': 4,
+  'none': 0,
+};
+
 async function cmdIssueCreate(args) {
   const opts = parseArgs(args, {
     title: 'string', t: 'string',
@@ -504,28 +703,30 @@ 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',
-    label: 'string', l: 'string',
-    blocks: 'string',
-    'blocked-by': 'string',
+    priority: '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 = opts.project || opts.p;
-  const milestone = opts.milestone;
+  const project = resolveAlias(opts.project || opts.p);
+  const priority = (opts.priority || '').toLowerCase();
+  const milestone = resolveAlias(opts.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'));
-    console.error('Usage: linear issue create --title "Issue title" [--project "..."] [--milestone "..."] [--parent ISSUE-X] [--estimate M] [--assign] [--label bug] [--blocks ISSUE-X] [--blocked-by ISSUE-X]');
+    console.error('Usage: linear issue create --title "Issue title" [--project "..."] [--milestone "..."] [--parent ISSUE-X] [--estimate M] [--priority urgent] [--assign] [--label bug] [--blocks ISSUE-X] [--blocked-by ISSUE-X]');
     process.exit(1);
   }
 
@@ -535,6 +736,12 @@ async function cmdIssueCreate(args) {
     process.exit(1);
   }
 
+  // Validate priority
+  if (priority && !PRIORITY_MAP.hasOwnProperty(priority)) {
+    console.error(colors.red(`Error: Invalid priority "${priority}". Use: urgent, high, medium, low, or none`));
+    process.exit(1);
+  }
+
   // Get team UUID (required for mutations)
   const teamResult = await gql(`{ team(id: "${TEAM_KEY}") { id } }`);
   const teamId = teamResult.data?.team?.id;
@@ -587,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.`));
+      }
     }
   }
 
@@ -626,6 +835,7 @@ async function cmdIssueCreate(args) {
   if (parent) input.parentId = parent;
   if (assigneeId) input.assigneeId = assigneeId;
   if (estimate) input.estimate = ESTIMATE_MAP[estimate];
+  if (priority) input.priority = PRIORITY_MAP[priority];
   if (labelIds.length > 0) input.labelIds = labelIds;
 
   const result = await gql(mutation, { input });
@@ -633,31 +843,30 @@ async function cmdIssueCreate(args) {
   if (result.data?.issueCreate?.success) {
     const issue = result.data.issueCreate.issue;
     const estLabel = estimate ? ` [${estimate.toUpperCase()}]` : '';
-    console.log(colors.green(`Created: ${issue.identifier}${estLabel}`));
+    const priLabel = priority && priority !== 'none' ? ` [${priority.charAt(0).toUpperCase() + priority.slice(1)}]` : '';
+    console.log(colors.green(`Created: ${issue.identifier}${estLabel}${priLabel}`));
     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 {
@@ -677,22 +886,61 @@ 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',
-    blocks: 'string',
-    'blocked-by': 'string',
+    check: 'string',
+    uncheck: 'string',
+    blocks: 'array',
+    'blocked-by': 'array',
   });
 
-  const blocksIssue = opts.blocks;
-  const blockedByIssue = opts['blocked-by'];
-  const projectName = opts.project || opts.p;
-  const milestoneName = opts.milestone;
+  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)) {
+      console.error(colors.red(`Error: Invalid priority "${priorityName}". Use: urgent, high, medium, low, or none`));
+      process.exit(1);
+    }
+    input.priority = PRIORITY_MAP[priorityName];
+  }
+
   // Handle append
   if (opts.append || opts.a) {
     const currentResult = await gql(`{ issue(id: "${issueId}") { description } }`);
@@ -702,9 +950,73 @@ async function cmdIssueUpdate(args) {
     input.description = opts.description || opts.d;
   }
 
+  // Handle check/uncheck
+  const checkText = opts.check;
+  const uncheckText = opts.uncheck;
+  if (checkText || uncheckText) {
+    const isCheck = !!checkText;
+    const query = checkText || uncheckText;
+    const fromPattern = isCheck ? /- \[ \] / : /- \[x\] /i;
+    const toMark = isCheck ? '- [x] ' : '- [ ] ';
+    const verb = isCheck ? 'Checked' : 'Unchecked';
+
+    // Fetch current description if we haven't already
+    let desc = input.description;
+    if (!desc) {
+      const currentResult = await gql(`{ issue(id: "${issueId}") { description } }`);
+      desc = currentResult.data?.issue?.description || '';
+    }
+
+    const lines = desc.split('\n');
+    const checkboxLines = lines
+      .map((line, i) => ({ line, index: i }))
+      .filter(({ line }) => fromPattern.test(line));
+
+    if (checkboxLines.length === 0) {
+      console.error(colors.red(`Error: No ${isCheck ? 'unchecked' : 'checked'} items found in description`));
+      process.exit(1);
+    }
+
+    // Find best match: score each checkbox line by similarity to query
+    const queryLower = query.toLowerCase();
+    let bestMatch = null;
+    let bestScore = 0;
+
+    for (const { line, index } of checkboxLines) {
+      const text = line.replace(/- \[[ x]\] /i, '').toLowerCase();
+      // Exact match
+      if (text === queryLower) { bestMatch = { line, index }; bestScore = Infinity; break; }
+      // Substring match
+      if (text.includes(queryLower) || queryLower.includes(text)) {
+        const score = queryLower.length / Math.max(text.length, queryLower.length);
+        if (score > bestScore) { bestScore = score; bestMatch = { line, index }; }
+      } else {
+        // Word overlap scoring
+        const queryWords = queryLower.split(/\s+/);
+        const textWords = text.split(/\s+/);
+        const overlap = queryWords.filter(w => textWords.some(tw => tw.includes(w) || w.includes(tw))).length;
+        const score = overlap / Math.max(queryWords.length, textWords.length);
+        if (score > bestScore) { bestScore = score; bestMatch = { line, index }; }
+      }
+    }
+
+    if (!bestMatch || bestScore < 0.3) {
+      console.error(colors.red(`Error: No checkbox matching "${query}"`));
+      console.error('Available items:');
+      checkboxLines.forEach(({ line }) => console.error('  ' + line.trim()));
+      process.exit(1);
+    }
+
+    lines[bestMatch.index] = bestMatch.line.replace(fromPattern, toMark);
+    input.description = lines.join('\n');
+
+    const itemText = bestMatch.line.replace(/- \[[ x]\] /i, '').trim();
+    console.log(colors.green(`${verb}: ${itemText}`));
+  }
+
   // 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 } }
@@ -715,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(`{
@@ -756,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'));
@@ -795,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}`));
     }
   }
 }
@@ -953,21 +1285,38 @@ async function cmdProjects(args) {
     projects = projects.filter(p => !['completed', 'canceled'].includes(p.state));
   }
 
+  // Find alias for a project (name must start with alias target)
+  const findAliasFor = (name) => {
+    const lowerName = name.toLowerCase();
+    let bestMatch = null;
+    let bestLength = 0;
+    for (const [code, aliasName] of Object.entries(ALIASES)) {
+      const lowerAlias = aliasName.toLowerCase();
+      // Name must start with the alias target, and prefer longer matches
+      if (lowerName.startsWith(lowerAlias) && lowerAlias.length > bestLength) {
+        bestMatch = code;
+        bestLength = lowerAlias.length;
+      }
+    }
+    return bestMatch;
+  };
+
   console.log(colors.bold('Projects:\n'));
-  const rows = projects.map(p => [
-    p.name,
-    p.state,
-    `${Math.floor(p.progress * 100)}%`
-  ]);
+  const rows = projects.map(p => {
+    const alias = findAliasFor(p.name);
+    const nameCol = alias ? `${colors.bold(`[${alias}]`)} ${p.name}` : p.name;
+    return [nameCol, p.state, `${Math.floor(p.progress * 100)}%`];
+  });
   console.log(formatTable(rows));
 }
 
 async function cmdProjectShow(args) {
-  const projectName = args[0];
-  if (!projectName) {
+  const projectNameArg = args[0];
+  if (!projectNameArg) {
     console.error(colors.red('Error: Project name required'));
     process.exit(1);
   }
+  const projectName = resolveAlias(projectNameArg);
 
   const query = `{
     team(id: "${TEAM_KEY}") {
@@ -982,7 +1331,7 @@ async function cmdProjectShow(args) {
 
   const result = await gql(query);
   const projects = result.data?.team?.projects?.nodes || [];
-  const project = projects.find(p => p.name.includes(projectName));
+  const project = projects.find(p => p.name.toLowerCase().includes(projectName.toLowerCase()));
 
   if (!project) {
     console.error(colors.red(`Project not found: ${projectName}`));
@@ -1129,34 +1478,58 @@ async function cmdMilestones(args) {
     projects = projects.filter(p => !['completed', 'canceled'].includes(p.state));
   }
 
-  // Filter by project name if specified
+  // Filter by project name if specified (resolve alias first)
   if (projectFilter) {
-    projects = projects.filter(p => p.name.toLowerCase().includes(projectFilter.toLowerCase()));
+    const resolvedFilter = resolveAlias(projectFilter);
+    projects = projects.filter(p => p.name.toLowerCase().includes(resolvedFilter.toLowerCase()));
   }
 
+  // Find alias for a name (name must start with alias target)
+  const findAliasFor = (name) => {
+    const lowerName = name.toLowerCase();
+    let bestMatch = null;
+    let bestLength = 0;
+    for (const [code, aliasName] of Object.entries(ALIASES)) {
+      const lowerAlias = aliasName.toLowerCase();
+      // Name must start with the alias target, and prefer longer matches
+      if (lowerName.startsWith(lowerAlias) && lowerAlias.length > bestLength) {
+        bestMatch = code;
+        bestLength = lowerAlias.length;
+      }
+    }
+    return bestMatch;
+  };
+
   console.log(colors.bold('Milestones:\n'));
   for (const project of projects) {
     const milestones = project.projectMilestones?.nodes || [];
     if (milestones.length === 0) continue;
 
-    console.log(colors.bold(project.name));
+    const projectAlias = findAliasFor(project.name);
+    const projectHeader = projectAlias
+      ? `${colors.bold(`[${projectAlias}]`)} ${colors.bold(project.name)}`
+      : colors.bold(project.name);
+    console.log(projectHeader);
     for (const m of milestones) {
+      const milestoneAlias = findAliasFor(m.name);
+      const namePrefix = milestoneAlias ? `${colors.bold(`[${milestoneAlias}]`)} ` : '';
       const date = m.targetDate ? ` (${m.targetDate})` : '';
       const status = m.status !== 'planned' ? ` [${m.status}]` : '';
-      console.log(`  ${m.name}${date}${status}`);
+      console.log(`  ${namePrefix}${m.name}${date}${status}`);
     }
     console.log('');
   }
 }
 
 async function cmdMilestoneShow(args) {
-  const milestoneName = args[0];
-  if (!milestoneName) {
+  const milestoneNameArg = args[0];
+  if (!milestoneNameArg) {
     console.error(colors.red('Error: Milestone name required'));
     process.exit(1);
   }
+  const milestoneName = resolveAlias(milestoneNameArg);
 
-  const query = `{
+  const projectsQuery = `{
     team(id: "${TEAM_KEY}") {
       projects(first: 50) {
         nodes {
@@ -1164,7 +1537,6 @@ async function cmdMilestoneShow(args) {
           projectMilestones {
             nodes {
               id name description targetDate status sortOrder
-              issues { nodes { identifier title state { name type } } }
             }
           }
         }
@@ -1172,8 +1544,23 @@ async function cmdMilestoneShow(args) {
     }
   }`;
 
-  const result = await gql(query);
-  const projects = result.data?.team?.projects?.nodes || [];
+  const issuesQuery = `{
+    team(id: "${TEAM_KEY}") {
+      issues(first: 200) {
+        nodes {
+          identifier title state { name type }
+          projectMilestone { id }
+        }
+      }
+    }
+  }`;
+
+  const [projectsResult, issuesResult] = await Promise.all([
+    gql(projectsQuery),
+    gql(issuesQuery)
+  ]);
+  const projects = projectsResult.data?.team?.projects?.nodes || [];
+  const allIssues = issuesResult.data?.team?.issues?.nodes || [];
 
   let milestone = null;
   let projectName = '';
@@ -1199,7 +1586,7 @@ async function cmdMilestoneShow(args) {
   if (milestone.targetDate) console.log(`Target: ${milestone.targetDate}`);
   if (milestone.description) console.log(`\n## Description\n${milestone.description}`);
 
-  const issues = milestone.issues?.nodes || [];
+  const issues = allIssues.filter(i => i.projectMilestone?.id === milestone.id);
   if (issues.length > 0) {
     // Group by state type
     const done = issues.filter(i => i.state.type === 'completed');
@@ -1910,6 +2297,77 @@ async function cmdLabelCreate(args) {
   }
 }
 
+// ============================================================================
+// ALIASES
+// ============================================================================
+
+async function cmdAlias(args) {
+  const opts = parseArgs(args, {
+    list: 'boolean', l: 'boolean',
+    remove: 'string', r: 'string',
+  });
+
+  const showList = opts.list || opts.l;
+  const removeCode = opts.remove || opts.r;
+  const code = opts._[0];
+  const name = opts._[1];
+
+  // List aliases
+  if (showList || (Object.keys(opts).length === 1 && opts._.length === 0)) {
+    const aliases = Object.entries(ALIASES);
+    if (aliases.length === 0) {
+      console.log('No aliases defined.');
+      console.log('Usage: linear alias CODE "Project or Milestone Name"');
+      return;
+    }
+
+    // Fetch projects to determine type (project vs milestone)
+    const query = `{
+      team(id: "${TEAM_KEY}") {
+        projects(first: 50) {
+          nodes { name }
+        }
+      }
+    }`;
+
+    const result = await gql(query);
+    const projects = result.data?.team?.projects?.nodes || [];
+
+    // Check if alias target matches a project (using partial match)
+    const matchesProject = (target) => {
+      const lowerTarget = target.toLowerCase();
+      return projects.some(p => p.name.toLowerCase().includes(lowerTarget));
+    };
+
+    console.log(colors.bold('Aliases:\n'));
+    for (const [code, target] of aliases) {
+      const isProject = matchesProject(target);
+      const type = isProject ? colors.blue('project') : colors.yellow('milestone');
+      console.log(`  ${colors.bold(code)} -> ${target} (${type})`);
+    }
+    return;
+  }
+
+  // Remove alias
+  if (removeCode) {
+    removeAlias(removeCode);
+    console.log(colors.green(`Removed alias: ${removeCode.toUpperCase()}`));
+    return;
+  }
+
+  // Create/update alias
+  if (!code || !name) {
+    console.error(colors.red('Error: Code and name required'));
+    console.error('Usage: linear alias CODE "Project or Milestone Name"');
+    console.error('       linear alias --list');
+    console.error('       linear alias --remove CODE');
+    process.exit(1);
+  }
+
+  saveAlias(code, name);
+  console.log(colors.green(`Alias set: ${code.toUpperCase()} -> ${name}`));
+}
+
 // ============================================================================
 // GIT INTEGRATION
 // ============================================================================
@@ -2339,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 } }');
@@ -2432,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'));
     }
   }
 
@@ -2737,17 +3189,16 @@ 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
 
   issue show <id>            Show issue details with parent context
@@ -2760,18 +3211,26 @@ ISSUES:
     --parent <id>            Parent issue (for sub-issues)
     --assign                 Assign to yourself
     --estimate, -e <size>    Estimate: XS, S, M, L, XL
-    --label, -l <name>       Add label
-    --blocks <id>            This issue blocks another
-    --blocked-by <id>        This issue is blocked by another
+    --priority <level>       Priority: urgent, high, medium, low, none
+    --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
-    --blocks <id>            Add blocking relation
-    --blocked-by <id>        Add blocked-by relation
+    --check <text>           Check a checkbox item (fuzzy match)
+    --uncheck <text>         Uncheck a checkbox item (fuzzy match)
+    --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
@@ -2816,6 +3275,15 @@ LABELS:
     --description, -d <desc> Label description
     --color, -c <hex>        Label color (e.g., #FF0000)
 
+ALIASES:
+  alias <CODE> "<name>"      Create alias for project/milestone
+  alias --list               List all aliases
+  alias --remove <CODE>      Remove an alias
+
+  Aliases can be used anywhere a project or milestone name is accepted:
+    linear issues --project LWW
+    linear issue create --milestone MVP "New feature"
+
 GIT:
   branch <id>                Create git branch from issue (ISSUE-5-issue-title)
 
@@ -2838,6 +3306,10 @@ CONFIGURATION:
     api_key=lin_api_xxx
     team=ISSUE
 
+    [aliases]
+    LWW=Last-Write-Wins Support
+    MVP=MVP Release
+
 EXAMPLES:
   linear roadmap             # See all projects and milestones
   linear issues --unblocked  # Find workable issues
@@ -2971,6 +3443,10 @@ async function main() {
         }
         break;
       }
+      case 'alias':
+        checkAuth();
+        await cmdAlias(args.slice(1));
+        break;
       case 'branch':
         checkAuth();
         await cmdBranch(args.slice(1));