@fink-andreas/pi-linear-tools 0.6.0 → 0.7.1

package/src/linear.js

@@ -288,7 +288,7 @@ const PROJECT_DELETE_MUTATION = `
 
 const PROJECT_ARCHIVE_MUTATION = `
   mutation ProjectArchive($id: String!) {
-    projectArchiveResult: projectDelete(id: $id) {
+    projectArchiveResult: projectArchive(id: $id) {
       success
       entity {
         id
@@ -1292,7 +1292,11 @@ async function fetchProjectMilestonesByQuery(client, projectId, options = {}) {
  * Track rate limit status from API responses
  * Linear API returns headers: X-RateLimit-Requests-Remaining, X-RateLimit-Requests-Reset
  */
+const DEFAULT_REQUEST_LIMIT = 5000;
+const LOW_RATE_LIMIT_THRESHOLD = 0.10;
+
 const rateLimitState = {
+  limit: DEFAULT_REQUEST_LIMIT,
   remaining: null,
   resetAt: null,
   lastWarnAt: 0,
@@ -1307,14 +1311,21 @@ function updateRateLimitState(response) {
 
   const headers = response.headers;
   if (headers) {
+    const limit = headers.get('X-RateLimit-Requests-Limit');
     const remaining = headers.get('X-RateLimit-Requests-Remaining');
     const resetAt = headers.get('X-RateLimit-Requests-Reset');
 
+    if (limit !== null) {
+      const parsedLimit = parseInt(limit, 10);
+      if (Number.isFinite(parsedLimit)) rateLimitState.limit = parsedLimit;
+    }
     if (remaining !== null) {
-      rateLimitState.remaining = parseInt(remaining, 10);
+      const parsedRemaining = parseInt(remaining, 10);
+      if (Number.isFinite(parsedRemaining)) rateLimitState.remaining = parsedRemaining;
     }
     if (resetAt !== null) {
-      rateLimitState.resetAt = parseInt(resetAt, 10);
+      const parsedResetAt = parseInt(resetAt, 10);
+      if (Number.isFinite(parsedResetAt)) rateLimitState.resetAt = parsedResetAt;
     }
   }
 }
@@ -1325,6 +1336,7 @@ function updateRateLimitState(response) {
  */
 export function getRateLimitStatus() {
   const result = {
+    limit: rateLimitState.limit,
     remaining: rateLimitState.remaining,
     resetAt: rateLimitState.resetAt,
     resetTime: null,
@@ -1335,9 +1347,10 @@ export function getRateLimitStatus() {
   if (rateLimitState.resetAt) {
     result.resetTime = new Date(rateLimitState.resetAt).toLocaleTimeString();
     const remaining = rateLimitState.remaining;
-    if (remaining !== null && remaining <= 1000) {
-      result.usagePercent = Math.round(((5000 - remaining) / 5000) * 100);
-      result.shouldWarn = remaining <= 500;
+    const limit = rateLimitState.limit || DEFAULT_REQUEST_LIMIT;
+    if (remaining !== null) {
+      result.usagePercent = Math.round((Math.max(0, limit - remaining) / limit) * 100);
+      result.shouldWarn = remaining <= Math.max(1, Math.floor(limit * LOW_RATE_LIMIT_THRESHOLD));
     }
   }
 
@@ -1356,6 +1369,7 @@ function checkRateLimitWarning() {
   if (status.shouldWarn && status.remaining !== null) {
     rateLimitState.lastWarnAt = now;
     warn(`Linear API rate limit running low: ${status.remaining} requests remaining (~${status.usagePercent}% used). Resets at ${status.resetTime}`, {
+      limit: status.limit,
       remaining: status.remaining,
       resetAt: status.resetTime,
       usagePercent: status.usagePercent,
@@ -1588,6 +1602,37 @@ function normalizeProjectUpdateHealth(value) {
   return normalized;
 }
 
+const ISSUE_PRIORITY_NAMES = ['No priority', 'Urgent', 'High', 'Medium', 'Low'];
+const ISSUE_PRIORITY_ALIASES = Object.freeze({
+  none: 0,
+  urgent: 1,
+  high: 2,
+  medium: 3,
+  low: 4,
+});
+const ISSUE_PRIORITY_MAPPING_DESCRIPTION = '0=None, 1=Urgent, 2=High, 3=Medium, 4=Low';
+const ISSUE_PRIORITY_ALIAS_DESCRIPTION = Object.keys(ISSUE_PRIORITY_ALIASES).join(', ');
+
+function parseIssuePriority(value) {
+  if (typeof value === 'number') {
+    if (Number.isInteger(value) && value >= 0 && value <= 4) {
+      return value;
+    }
+  } else if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    if (Object.prototype.hasOwnProperty.call(ISSUE_PRIORITY_ALIASES, normalized)) {
+      return ISSUE_PRIORITY_ALIASES[normalized];
+    }
+    if (/^[0-4]$/.test(normalized)) {
+      return Number(normalized);
+    }
+  }
+
+  throw new Error(
+    `Invalid priority: ${value}. Use Linear priority ${ISSUE_PRIORITY_MAPPING_DESCRIPTION}, or one of: ${ISSUE_PRIORITY_ALIAS_DESCRIPTION}.`
+  );
+}
+
 function formatPriorityLabel(value) {
   if (value === undefined || value === null) {
     return null;
@@ -1598,8 +1643,7 @@ function formatPriorityLabel(value) {
     return String(value);
   }
 
-  const priorityNames = ['No priority', 'Urgent', 'High', 'Medium', 'Low'];
-  return priorityNames[numeric] || `Priority ${numeric}`;
+  return ISSUE_PRIORITY_NAMES[numeric] || `Priority ${numeric}`;
 }
 
 function getUserDisplayName(user) {
@@ -2859,6 +2903,145 @@ export async function fetchIssueDetails(client, issueRef, options = {}) {
   }, 'fetchIssueDetails');
 }
 
+function extractMarkdownImages(markdown, source) {
+  if (!markdown || typeof markdown !== 'string') return [];
+
+  const images = [];
+  const markdownImagePattern = /!\[([^\]]*)\]\(([^\s)]+)(?:\s+"[^"]*")?\)/g;
+  const htmlImagePattern = /<img\b[^>]*\bsrc=["']([^"']+)["'][^>]*>/gi;
+
+  let match;
+  while ((match = markdownImagePattern.exec(markdown)) !== null) {
+    images.push({ alt: match[1] || null, url: match[2], source });
+  }
+  while ((match = htmlImagePattern.exec(markdown)) !== null) {
+    images.push({ alt: null, url: match[1], source });
+  }
+
+  return images;
+}
+
+function isImageUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+  } catch {
+    return false;
+  }
+}
+
+function isLinearUploadUrl(url) {
+  try {
+    const hostname = new URL(url).hostname.toLowerCase();
+    return hostname === 'uploads.linear.app' || hostname.endsWith('.uploads.linear.app');
+  } catch {
+    return false;
+  }
+}
+
+function getLinearAuthHeaderValue(client, mode = 'raw') {
+  const token = client?.__piLinearTrackerKey || client?.apiKey || null;
+  if (!token || token === 'default') return null;
+  return mode === 'bearer' ? `Bearer ${token}` : token;
+}
+
+async function fetchImageUrl(client, url, options = {}) {
+  const { maxBytes = 10 * 1024 * 1024 } = options;
+  const attempts = [{ headers: {} }];
+
+  if (isLinearUploadUrl(url)) {
+    const rawAuth = getLinearAuthHeaderValue(client, 'raw');
+    const bearerAuth = getLinearAuthHeaderValue(client, 'bearer');
+    if (rawAuth) attempts.push({ headers: { authorization: rawAuth } });
+    if (bearerAuth) attempts.push({ headers: { authorization: bearerAuth } });
+  }
+
+  let lastError = null;
+  for (const attempt of attempts) {
+    try {
+      const response = await fetch(url, { headers: attempt.headers, redirect: 'follow' });
+      if (!response.ok) {
+        lastError = new Error(`HTTP ${response.status} ${response.statusText}`);
+        continue;
+      }
+
+      const contentType = response.headers.get('content-type') || 'application/octet-stream';
+      if (!contentType.toLowerCase().startsWith('image/')) {
+        lastError = new Error(`URL did not return an image (content-type: ${contentType})`);
+        continue;
+      }
+
+      const contentLength = Number(response.headers.get('content-length') || 0);
+      if (contentLength > maxBytes) {
+        throw new Error(`Image is too large (${contentLength} bytes, max ${maxBytes})`);
+      }
+
+      const buffer = Buffer.from(await response.arrayBuffer());
+      if (buffer.length > maxBytes) {
+        throw new Error(`Image is too large (${buffer.length} bytes, max ${maxBytes})`);
+      }
+
+      return {
+        data: buffer.toString('base64'),
+        mimeType: contentType.split(';')[0].trim() || 'application/octet-stream',
+        sizeBytes: buffer.length,
+      };
+    } catch (error) {
+      lastError = error;
+    }
+  }
+
+  throw lastError || new Error('Failed to fetch image');
+}
+
+export async function fetchIssueImages(client, issueRef, options = {}) {
+  return withLinearErrorHandling(async () => {
+    const { includeComments = true, limit = 10, maxBytes = 10 * 1024 * 1024 } = options;
+    const issueData = await fetchIssueDetails(client, issueRef, { includeComments });
+    const candidates = [];
+
+    candidates.push(...extractMarkdownImages(issueData.description, 'description'));
+    if (includeComments) {
+      for (const comment of issueData.comments || []) {
+        candidates.push(...extractMarkdownImages(comment.body, `comment:${comment.id}`));
+      }
+    }
+
+    const seen = new Set();
+    const uniqueCandidates = candidates
+      .filter((candidate) => candidate.url && isImageUrl(candidate.url))
+      .filter((candidate) => {
+        if (seen.has(candidate.url)) return false;
+        seen.add(candidate.url);
+        return true;
+      })
+      .slice(0, limit);
+
+    const images = [];
+    const failures = [];
+    for (const candidate of uniqueCandidates) {
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const image = await fetchImageUrl(client, candidate.url, { maxBytes });
+        images.push({ ...candidate, ...image });
+      } catch (error) {
+        failures.push({ ...candidate, error: error?.message || String(error) });
+      }
+    }
+
+    return {
+      issue: {
+        identifier: issueData.identifier,
+        title: issueData.title,
+        url: issueData.url,
+      },
+      images,
+      failures,
+      totalCandidates: candidates.length,
+    };
+  }, 'fetchIssueImages');
+}
+
 export async function fetchIssueActivity(client, issueRef, options = {}) {
   return withLinearErrorHandling(async () => {
     const limit = normalizePositiveInteger(options.limit, 'limit', 20);
@@ -2965,8 +3148,9 @@ export async function setIssueState(client, issueId, stateId) {
  * @param {string} input.title - Issue title (required)
  * @param {string} [input.description] - Issue description
  * @param {string} [input.projectId] - Project ID
- * @param {string} [input.priority] - Priority 0-4
+ * @param {number|string} [input.priority] - Issue priority: 0=None, 1=Urgent, 2=High, 3=Medium, 4=Low; or none/urgent/high/medium/low
  * @param {string} [input.assigneeId] - Assignee ID
+ * @param {string} [input.projectMilestoneId] - Project milestone ID
  * @param {string} [input.parentId] - Parent issue ID for sub-issues
  * @returns {Promise<Object>} Created issue
  */
@@ -2996,11 +3180,7 @@ export async function createIssue(client, input) {
     }
 
     if (input.priority !== undefined) {
-      const parsed = Number.parseInt(String(input.priority), 10);
-      if (Number.isNaN(parsed) || parsed < 0 || parsed > 4) {
-        throw new Error(`Invalid priority: ${input.priority}. Valid range: 0..4`);
-      }
-      createInput.priority = parsed;
+      createInput.priority = parseIssuePriority(input.priority);
     }
 
     if (input.estimate !== undefined) {
@@ -3023,6 +3203,10 @@ export async function createIssue(client, input) {
       createInput.stateId = input.stateId;
     }
 
+    if (input.projectMilestoneId !== undefined) {
+      createInput.projectMilestoneId = input.projectMilestoneId;
+    }
+
     if (getRawRequest(client)) {
       const payload = await executeGraphQL(client, ISSUE_CREATE_MUTATION, { input: createInput });
       if (!payload?.issueCreate?.success) {
@@ -3062,10 +3246,13 @@ export async function createIssue(client, input) {
         title,
         description: input.description ?? null,
         url: null,
-        priority: input.priority ?? null,
+        priority: createInput.priority ?? null,
         state: null,
         team: null,
         project: null,
+        projectMilestone: createInput.projectMilestoneId
+          ? { id: createInput.projectMilestoneId, name: 'Unknown' }
+          : null,
         assignee: null,
       };
     }
@@ -3076,10 +3263,13 @@ export async function createIssue(client, input) {
       title,
       description: input.description ?? null,
       url: null,
-      priority: input.priority ?? null,
+      priority: createInput.priority ?? null,
       state: null,
       team: null,
       project: null,
+      projectMilestone: createInput.projectMilestoneId
+        ? { id: createInput.projectMilestoneId, name: 'Unknown' }
+        : null,
       assignee: null,
     };
   }, 'createIssue');
@@ -3209,11 +3399,7 @@ export async function updateIssue(client, issueRef, patch = {}) {
     }
 
     if (patch.priority !== undefined) {
-      const parsed = Number.parseInt(String(patch.priority), 10);
-      if (Number.isNaN(parsed) || parsed < 0 || parsed > 4) {
-        throw new Error(`Invalid priority: ${patch.priority}. Valid range: 0..4`);
-      }
-      updateInput.priority = parsed;
+      updateInput.priority = parseIssuePriority(patch.priority);
     }
 
 

package/src/settings.js

@@ -22,6 +22,7 @@ export function getDefaultSettings() {
     defaultWorkspace: null,
     projects: {},
     rateLimitDebug: false, // Enable detailed rate limit info per tool call
+    allow_overwrite_files: false, // Require explicit opt-in before tools can overwrite local files
   };
 }
 
@@ -117,6 +118,11 @@ function migrateSettings(settings) {
     migrated.rateLimitDebug = false;
   }
 
+  // Ensure local file overwrite guard is disabled by default
+  if (migrated.allow_overwrite_files === undefined) {
+    migrated.allow_overwrite_files = false;
+  }
+
   // Migrate project scopes
   for (const [projectId, cfg] of Object.entries(migrated.projects)) {
     if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) {
@@ -227,6 +233,11 @@ export function validateSettings(settings) {
     errors.push('settings.rateLimitDebug must be a boolean');
   }
 
+  // Validate local file overwrite guard
+  if (settings.allow_overwrite_files !== undefined && typeof settings.allow_overwrite_files !== 'boolean') {
+    errors.push('settings.allow_overwrite_files must be a boolean');
+  }
+
   return { valid: errors.length === 0, errors };
 }