@link-assistant/hive-mind 0.39.0

package/src/agent.prompts.lib.mjs

@@ -0,0 +1,196 @@
+/**
+ * Agent prompts module
+ * Handles building prompts for Agent commands
+ */
+
+/**
+ * Build the user prompt for Agent
+ * @param {Object} params - Parameters for building the user prompt
+ * @returns {string} The formatted user prompt
+ */
+export const buildUserPrompt = (params) => {
+  const {
+    issueUrl,
+    issueNumber,
+    prNumber,
+    prUrl,
+    branchName,
+    tempDir,
+    isContinueMode,
+    forkedRepo,
+    feedbackLines,
+    forkActionsUrl,
+    owner,
+    repo,
+    argv
+  } = params;
+
+  const promptLines = [];
+
+  // Issue or PR reference
+  if (isContinueMode) {
+    promptLines.push(`Issue to solve: ${issueNumber ? `https://github.com/${owner}/${repo}/issues/${issueNumber}` : `Issue linked to PR #${prNumber}`}`);
+  } else {
+    promptLines.push(`Issue to solve: ${issueUrl}`);
+  }
+
+  // Basic info
+  promptLines.push(`Your prepared branch: ${branchName}`);
+  promptLines.push(`Your prepared working directory: ${tempDir}`);
+
+  // PR info if available
+  if (prUrl) {
+    promptLines.push(`Your prepared Pull Request: ${prUrl}`);
+  }
+
+  // Fork info if applicable
+  if (argv && argv.fork && forkedRepo) {
+    promptLines.push(`Your forked repository: ${forkedRepo}`);
+    promptLines.push(`Original repository (upstream): ${owner}/${repo}`);
+
+    // Check for GitHub Actions on fork
+    if (branchName && forkActionsUrl) {
+      promptLines.push(`GitHub Actions on your fork: ${forkActionsUrl}`);
+    }
+  }
+
+  // Add blank line
+  promptLines.push('');
+
+  // Add feedback info if in continue mode and there are feedback items
+  if (isContinueMode && feedbackLines && feedbackLines.length > 0) {
+    // Add each feedback line directly
+    feedbackLines.forEach(line => promptLines.push(line));
+    promptLines.push('');
+  }
+
+  // Add thinking instruction based on --think level
+  if (argv && argv.think) {
+    const thinkMessages = {
+      low: 'Think.',
+      medium: 'Think hard.',
+      high: 'Think harder.',
+      max: 'Ultrathink.'
+    };
+    promptLines.push(thinkMessages[argv.think]);
+  }
+
+  // Final instruction
+  promptLines.push(isContinueMode ? 'Continue.' : 'Proceed.');
+
+  // Build the final prompt
+  return promptLines.join('\n');
+};
+
+/**
+ * Build the system prompt for Agent - adapted for Agent's capabilities
+ * @param {Object} params - Parameters for building the prompt
+ * @returns {string} The formatted system prompt
+ */
+export const buildSystemPrompt = (params) => {
+  const { owner, repo, issueNumber, prNumber, branchName, argv } = params;
+
+  // Build thinking instruction based on --think level
+  let thinkLine = '';
+  if (argv && argv.think) {
+    const thinkMessages = {
+      low: 'You always think on every step.',
+      medium: 'You always think hard on every step.',
+      high: 'You always think harder on every step.',
+      max: 'You always ultrathink on every step.'
+    };
+    thinkLine = `\n${thinkMessages[argv.think]}\n`;
+  }
+
+  return `You are AI issue solver using @link-assistant/agent.${thinkLine}
+
+General guidelines.
+   - When you execute commands, always save their logs to files for easier reading if the output becomes large.
+   - When running commands, do not set a timeout yourself — let them run as long as needed.
+   - When running sudo commands (especially package installations), always run them in the background to avoid timeout issues.
+   - When CI is failing, make sure you download the logs locally and carefully investigate them.
+   - When a code or log file has more than 1500 lines, read it in chunks of 1500 lines.
+   - When facing a complex problem, do as much tracing as possible and turn on all verbose modes.
+   - When you create debug, test, or example/experiment scripts for fixing, always keep them in an examples and/or experiments folders so you can reuse them later.
+   - When testing your assumptions, use the experiment scripts, and add it to experiments folder.
+   - When your experiments can show real world use case of the software, add it to examples folder.
+   - When you face something extremely hard, use divide and conquer — it always helps.
+
+Initial research.
+   - When you start, make sure you create detailed plan for yourself and follow your todo list step by step, make sure that as many points from these guidelines are added to your todo list to keep track of everything that can help you solve the issue with highest possible quality.
+   - When you read issue, read all details and comments thoroughly.
+   - When you see screenshots or images in issue descriptions, pull request descriptions, comments, or discussions, use WebFetch tool to download the image first, then use Read tool to view and analyze it.
+   - When you need issue details, use gh issue view https://github.com/${owner}/${repo}/issues/${issueNumber}.
+   - When you need related code, use gh search code --owner ${owner} [keywords].
+   - When you need repo context, read files in your working directory.
+   - When you study related work, study the most recent related pull requests.
+   - When issue is not defined enough, write a comment to ask clarifying questions.
+   - When accessing GitHub Gists, use gh gist view command instead of direct URL fetching.
+   - When you are fixing a bug, please make sure you first find the actual root cause, do as many experiments as needed.
+   - When you are fixing a bug and code does not have enough tracing/logs, add them and make sure they stay in the code, but are switched off by default.
+   - When you need latest comments on pull request, use gh api repos/${owner}/${repo}/pulls/${prNumber}/comments.
+   - When you need latest comments on issue, use gh api repos/${owner}/${repo}/issues/${issueNumber}/comments.
+
+Solution development and testing.
+   - When issue is solvable, implement code with tests.
+   - When coding, each atomic step that can be useful by itself should be commited to the pull request's branch, meaning if work will be interrupted by any reason parts of solution will still be kept intact and safe in pull request.
+   - When you test:
+      start from testing of small functions using separate scripts;
+      write unit tests with mocks for easy and quick start.
+   - When you test integrations, use existing framework.
+   - When you test solution draft, include automated checks in pr.
+   - When issue is unclear, write comment on issue asking questions.
+   - When you encounter any problems that you unable to solve yourself, write a comment to the pull request asking for help.
+   - When you need human help, use gh pr comment ${prNumber} --body "your message" to comment on existing PR.
+
+Preparing pull request.
+   - When you code, follow contributing guidelines.
+   - When you commit, write clear message.
+   - When you need examples of style, use gh pr list --repo ${owner}/${repo} --state merged --search [keywords].
+   - When you open pr, describe solution draft and include tests.
+   - When there is a package with version and GitHub Actions workflows for automatic release, update the version in your pull request to prepare for next release.
+   - When you update existing pr ${prNumber}, use gh pr edit to modify title and description.
+   - When you finalize the pull request:
+      follow style from merged prs for code, title, and description,
+      make sure no uncommitted changes corresponding to the original requirements are left behind,
+      make sure the default branch is merged to the pull request's branch,
+      make sure all CI checks passing if they exist before you finish,
+      check for latest comments on the issue and pull request to ensure no recent feedback was missed,
+      double-check that all changes in the pull request answer to original requirements of the issue,
+      make sure no new bugs are introduced in pull request by carefully reading gh pr diff,
+      make sure no previously existing features were removed without an explicit request from users via the issue description, issue comments, and/or pull request comments.
+   - When you finish implementation, use gh pr ready ${prNumber}.
+
+Workflow and collaboration.
+   - When you check branch, verify with git branch --show-current.
+   - When you push, push only to branch ${branchName}.
+   - When you finish, create a pull request from branch ${branchName}.
+   - When pr ${prNumber} already exists for this branch, update it instead of creating new one.
+   - When you organize workflow, use pull requests instead of direct merges to default branch (main or master).
+   - When you manage commits, preserve commit history for later analysis.
+   - When you contribute, keep repository history forward-moving with regular commits, pushes, and reverts if needed.
+   - When you face conflict that you cannot resolve yourself, ask for help.
+   - When you collaborate, respect branch protections by working only on ${branchName}.
+   - When you mention result, include pull request url or comment url.
+   - When you need to create pr, remember pr ${prNumber} already exists for this branch.
+
+Self review.
+   - When you check your solution draft, run all tests locally.
+   - When you check your solution draft, verify git status shows a clean working tree with no uncommitted changes.
+   - When you compare with repo style, use gh pr diff [number].
+   - When you finalize, confirm code, tests, and description are consistent.
+
+GitHub CLI command patterns.
+   - When listing PR comments, use gh api repos/OWNER/REPO/pulls/NUMBER/comments.
+   - When listing issue comments, use gh api repos/OWNER/REPO/issues/NUMBER/comments.
+   - When adding PR comment, use gh pr comment NUMBER --body "text" --repo OWNER/REPO.
+   - When adding issue comment, use gh issue comment NUMBER --body "text" --repo OWNER/REPO.
+   - When viewing PR details, use gh pr view NUMBER --repo OWNER/REPO.
+   - When filtering with jq, use gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --jq 'reverse | .[0:5]'.`;
+};
+
+// Export all functions as default object too
+export default {
+  buildUserPrompt,
+  buildSystemPrompt
+};

package/src/buildUserMention.lib.mjs

@@ -0,0 +1,71 @@
+/**
+ * Build a Telegram user mention link in various parse modes.
+ *
+ * This is a simplified version that doesn't require external dependencies.
+ * It handles the most common cases for Telegram user mentions.
+ *
+ * @param {Object} options - Options for building the mention link.
+ * @param {Object} [options.user] - Telegram user object with id, username, first_name, last_name.
+ * @param {number|string} [options.id] - Telegram user ID (overrides user.id).
+ * @param {string} [options.username] - Telegram username (without '@', overrides user.username).
+ * @param {string} [options.first_name] - User's first name (overrides user.first_name).
+ * @param {string} [options.last_name] - User's last name (overrides user.last_name).
+ * @param {'HTML'|'Markdown'|'MarkdownV2'} [options.parseMode='HTML'] - The parse mode to use.
+ * @returns {string} A formatted mention link for the user.
+ */
+export function buildUserMention({
+  user,
+  id: idParam,
+  username: usernameParam,
+  first_name: firstNameParam,
+  last_name: lastNameParam,
+  parseMode = 'HTML',
+}) {
+  // Derive core fields from `user` with inline overrides
+  const id = idParam ?? user?.id;
+  const username = usernameParam ?? user?.username;
+  const firstName = firstNameParam ?? user?.first_name;
+  const lastName = lastNameParam ?? user?.last_name;
+
+  let displayName;
+  if (username) {
+    displayName = `@${username}`;
+  } else {
+    // Trim all string names, then filter out empty values
+    const raw = [firstName, lastName];
+    // Trim whitespace and Hangul filler (ㅤ) characters from names
+    const trimmedAll = raw.map((rawName) => (
+      typeof rawName === 'string' ? rawName.trim().replace(/^[\s\t\n\rㅤ]+|[\s\t\n\rㅤ]+$/g, '') : rawName
+    ));
+    const cleaned = trimmedAll.filter((name) => typeof name === 'string' && name.length > 0);
+    // Use cleaned names or fallback to id
+    if (cleaned.length > 0) {
+      displayName = cleaned.join(' ');
+    } else {
+      displayName = String(id);
+    }
+  }
+
+  const link = username ? `https://t.me/${username}` : `tg://user?id=${id}`;
+
+  switch (parseMode) {
+    case 'Markdown':
+      // Legacy Markdown: [text](url)
+      return `[${displayName}](${link})`;
+    case 'MarkdownV2': {
+      // MarkdownV2 requires escaping special characters
+      const escapedName = displayName.replace(/([_*[\]()~`>#+\-=|{}.!])/g, '\\$1');
+      return `[${escapedName}](${link})`;
+    }
+    case 'HTML':
+    default: {
+      // HTML mode: <a href="url">text</a>
+      const escapedHtml = displayName
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+      return `<a href="${link}">${escapedHtml}</a>`;
+    }
+  }
+}

package/src/claude-limits.lib.mjs

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+/**
+ * Claude usage limits library
+ * Provides functions to fetch and parse Claude usage limits via OAuth API
+ */
+
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/**
+ * Default path to Claude credentials file
+ */
+const DEFAULT_CREDENTIALS_PATH = join(homedir(), '.claude', '.credentials.json');
+
+/**
+ * Anthropic OAuth usage API endpoint
+ */
+const USAGE_API_ENDPOINT = 'https://api.anthropic.com/api/oauth/usage';
+
+/**
+ * Read Claude credentials from the credentials file
+ *
+ * @param {string} credentialsPath - Path to credentials file (optional)
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Object|null} Credentials object or null if not found
+ */
+async function readCredentials(credentialsPath = DEFAULT_CREDENTIALS_PATH, verbose = false) {
+  try {
+    const content = await readFile(credentialsPath, 'utf-8');
+    const credentials = JSON.parse(content);
+
+    if (verbose) {
+      console.log('[VERBOSE] /limits credentials loaded from:', credentialsPath);
+    }
+
+    return credentials;
+  } catch (error) {
+    if (verbose) {
+      console.error('[VERBOSE] /limits failed to read credentials:', error.message);
+    }
+    return null;
+  }
+}
+
+/**
+ * Format an ISO date string to a human-readable reset time
+ *
+ * @param {string} isoDate - ISO date string (e.g., "2025-12-03T17:59:59.626485+00:00")
+ * @param {boolean} includeTimezone - Whether to include timezone suffix (default: true)
+ * @returns {string} Human-readable reset time (e.g., "Dec 3, 6:59pm UTC")
+ */
+function formatResetTime(isoDate, includeTimezone = true) {
+  if (!isoDate) return null;
+
+  try {
+    const date = new Date(isoDate);
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    const month = months[date.getUTCMonth()];
+    const day = date.getUTCDate();
+    const hours = date.getUTCHours();
+    const minutes = date.getUTCMinutes();
+
+    // Convert 24h to 12h format
+    const hour12 = hours === 0 ? 12 : hours > 12 ? hours - 12 : hours;
+    const ampm = hours >= 12 ? 'pm' : 'am';
+
+    const timeStr = `${month} ${day}, ${hour12}:${minutes.toString().padStart(2, '0')}${ampm}`;
+    return includeTimezone ? `${timeStr} UTC` : timeStr;
+  } catch {
+    return isoDate;
+  }
+}
+
+/**
+ * Format relative time from now to a future date
+ *
+ * @param {string} isoDate - ISO date string
+ * @returns {string|null} Relative time string (e.g., "1h 34m" or "6d 20h 13m") or null if date is in the past
+ */
+function formatRelativeTime(isoDate) {
+  if (!isoDate) return null;
+
+  try {
+    const now = new Date();
+    const target = new Date(isoDate);
+    const diffMs = target - now;
+
+    // Check for invalid date (NaN)
+    if (isNaN(diffMs)) return null;
+
+    if (diffMs < 0) return null; // Past date
+
+    const totalHours = Math.floor(diffMs / (1000 * 60 * 60));
+    const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60));
+
+    // If hours >= 24, show days
+    if (totalHours >= 24) {
+      const days = Math.floor(totalHours / 24);
+      const hours = totalHours % 24;
+      return `${days}d ${hours}h ${minutes}m`;
+    }
+
+    return `${totalHours}h ${minutes}m`;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Format current time in UTC
+ *
+ * @returns {string} Current time in UTC (e.g., "Dec 3, 6:45pm UTC")
+ */
+function formatCurrentTime() {
+  const now = new Date();
+  const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+  const month = months[now.getUTCMonth()];
+  const day = now.getUTCDate();
+  const hours = now.getUTCHours();
+  const minutes = now.getUTCMinutes();
+
+  // Convert 24h to 12h format
+  const hour12 = hours === 0 ? 12 : hours > 12 ? hours - 12 : hours;
+  const ampm = hours >= 12 ? 'pm' : 'am';
+
+  return `${month} ${day}, ${hour12}:${minutes.toString().padStart(2, '0')}${ampm} UTC`;
+}
+
+/**
+ * Get Claude usage limits by calling the Anthropic OAuth usage API
+ * This approach is more reliable than trying to parse CLI output
+ * and doesn't require the 'expect' command.
+ *
+ * Returns usage data for:
+ * - Current session (five_hour) usage percentage and reset time
+ * - Current week (all models / seven_day) usage percentage and reset date
+ * - Current week (Sonnet only / seven_day_sonnet) usage percentage and reset date
+ *
+ * @param {boolean} verbose - Whether to log verbose output
+ * @param {string} credentialsPath - Optional path to credentials file
+ * @returns {Object} Object with success boolean, and either usage data or error message
+ */
+export async function getClaudeUsageLimits(verbose = false, credentialsPath = DEFAULT_CREDENTIALS_PATH) {
+  try {
+    // Read credentials
+    const credentials = await readCredentials(credentialsPath, verbose);
+
+    if (!credentials) {
+      return {
+        success: false,
+        error: 'Could not read Claude credentials. Make sure Claude is properly installed and authenticated.'
+      };
+    }
+
+    const accessToken = credentials?.claudeAiOauth?.accessToken;
+
+    if (!accessToken) {
+      return {
+        success: false,
+        error: 'No access token found in Claude credentials. Please use `/solve` or `/hive` commands to trigger re-authentication of Claude.'
+      };
+    }
+
+    if (verbose) {
+      console.log('[VERBOSE] /limits fetching usage from API...');
+    }
+
+    // Call the Anthropic OAuth usage API
+    const response = await fetch(USAGE_API_ENDPOINT, {
+      method: 'GET',
+      headers: {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+        'User-Agent': 'claude-code/2.0.55',
+        'Authorization': `Bearer ${accessToken}`,
+        'anthropic-beta': 'oauth-2025-04-20'
+      }
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (verbose) {
+        console.error('[VERBOSE] /limits API error:', response.status, errorText);
+      }
+
+      // Check for specific error conditions
+      if (response.status === 401) {
+        return {
+          success: false,
+          error: 'Claude authentication expired. Please use `/solve` or `/hive` commands to trigger re-authentication of Claude.'
+        };
+      }
+
+      return {
+        success: false,
+        error: `Failed to fetch usage from API: ${response.status} ${response.statusText}`
+      };
+    }
+
+    const data = await response.json();
+
+    if (verbose) {
+      console.log('[VERBOSE] /limits API response:', JSON.stringify(data, null, 2));
+    }
+
+    // Parse the API response
+    // API returns:
+    // - five_hour: { utilization: number, resets_at: string }
+    // - seven_day: { utilization: number, resets_at: string }
+    // - seven_day_sonnet: { utilization: number, resets_at: string } (optional)
+
+    const usage = {
+      currentSession: {
+        percentage: data.five_hour?.utilization ?? null,
+        resetTime: formatResetTime(data.five_hour?.resets_at),
+        resetsAt: data.five_hour?.resets_at ?? null
+      },
+      allModels: {
+        percentage: data.seven_day?.utilization ?? null,
+        resetTime: formatResetTime(data.seven_day?.resets_at),
+        resetsAt: data.seven_day?.resets_at ?? null
+      },
+      sonnetOnly: {
+        percentage: data.seven_day_sonnet?.utilization ?? null,
+        resetTime: formatResetTime(data.seven_day_sonnet?.resets_at),
+        resetsAt: data.seven_day_sonnet?.resets_at ?? null
+      }
+    };
+
+    return {
+      success: true,
+      usage
+    };
+  } catch (error) {
+    if (verbose) {
+      console.error('[VERBOSE] /limits error:', error);
+    }
+    return {
+      success: false,
+      error: `Failed to get usage limits: ${error.message}`
+    };
+  }
+}
+
+/**
+ * Generate a text-based progress bar for usage percentage
+ * @param {number} percentage - Usage percentage (0-100)
+ * @returns {string} Text-based progress bar
+ */
+export function getProgressBar(percentage) {
+  const totalBlocks = 30;
+  const filledBlocks = Math.round((percentage / 100) * totalBlocks);
+  const emptyBlocks = totalBlocks - filledBlocks;
+  return '\u2593'.repeat(filledBlocks) + '\u2591'.repeat(emptyBlocks);
+}
+
+/**
+ * Calculate the percentage of time that has passed in a period
+ * @param {string} resetsAt - ISO date string when the period resets
+ * @param {number} periodHours - Total duration of the period in hours (5 for session, 168 for week)
+ * @returns {number|null} Percentage of time passed (0-100) or null if unable to calculate
+ */
+export function calculateTimePassedPercentage(resetsAt, periodHours) {
+  if (!resetsAt) return null;
+
+  try {
+    const now = new Date();
+    const resetTime = new Date(resetsAt);
+    const periodMs = periodHours * 60 * 60 * 1000; // Convert hours to milliseconds
+
+    // Calculate when the period started
+    const startTime = new Date(resetTime.getTime() - periodMs);
+
+    // Calculate time passed and total duration
+    const timePassed = now.getTime() - startTime.getTime();
+    const percentage = Math.max(0, Math.min(100, (timePassed / periodMs) * 100));
+
+    return Math.round(percentage);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Format Claude usage data into a Telegram-friendly message
+ * @param {Object} usage - The usage object from getClaudeUsageLimits
+ * @returns {string} Formatted message
+ */
+export function formatUsageMessage(usage) {
+  // Use code block for monospace font to align progress bars properly
+  let message = '```\n';
+
+  // Show current time
+  message += `Current time: ${formatCurrentTime()}\n\n`;
+
+  // Current session (five_hour)
+  message += 'Current session\n';
+  if (usage.currentSession.percentage !== null) {
+    // Add time passed progress bar first
+    const timePassed = calculateTimePassedPercentage(usage.currentSession.resetsAt, 5);
+    if (timePassed !== null) {
+      const timeBar = getProgressBar(timePassed);
+      message += `${timeBar} ${timePassed}% passed\n`;
+    }
+
+    // Add usage progress bar second
+    const pct = usage.currentSession.percentage;
+    const bar = getProgressBar(pct);
+    message += `${bar} ${pct}% used\n`;
+
+    if (usage.currentSession.resetTime) {
+      const relativeTime = formatRelativeTime(usage.currentSession.resetsAt);
+      if (relativeTime) {
+        message += `Resets in ${relativeTime} (${usage.currentSession.resetTime})\n`;
+      } else {
+        message += `Resets ${usage.currentSession.resetTime}\n`;
+      }
+    }
+  } else {
+    message += 'N/A\n';
+  }
+  message += '\n';
+
+  // Current week (all models / seven_day)
+  message += 'Current week (all models)\n';
+  if (usage.allModels.percentage !== null) {
+    // Add time passed progress bar first (168 hours = 7 days)
+    const timePassed = calculateTimePassedPercentage(usage.allModels.resetsAt, 168);
+    if (timePassed !== null) {
+      const timeBar = getProgressBar(timePassed);
+      message += `${timeBar} ${timePassed}% passed\n`;
+    }
+
+    // Add usage progress bar second
+    const pct = usage.allModels.percentage;
+    const bar = getProgressBar(pct);
+    message += `${bar} ${pct}% used\n`;
+
+    if (usage.allModels.resetTime) {
+      const relativeTime = formatRelativeTime(usage.allModels.resetsAt);
+      if (relativeTime) {
+        message += `Resets in ${relativeTime} (${usage.allModels.resetTime})\n`;
+      } else {
+        message += `Resets ${usage.allModels.resetTime}\n`;
+      }
+    }
+  } else {
+    message += 'N/A\n';
+  }
+  message += '\n';
+
+  // Current week (Sonnet only / seven_day_sonnet)
+  message += 'Current week (Sonnet only)\n';
+  if (usage.sonnetOnly.percentage !== null) {
+    // Add time passed progress bar first (168 hours = 7 days)
+    const timePassed = calculateTimePassedPercentage(usage.sonnetOnly.resetsAt, 168);
+    if (timePassed !== null) {
+      const timeBar = getProgressBar(timePassed);
+      message += `${timeBar} ${timePassed}% passed\n`;
+    }
+
+    // Add usage progress bar second
+    const pct = usage.sonnetOnly.percentage;
+    const bar = getProgressBar(pct);
+    message += `${bar} ${pct}% used\n`;
+
+    if (usage.sonnetOnly.resetTime) {
+      const relativeTime = formatRelativeTime(usage.sonnetOnly.resetsAt);
+      if (relativeTime) {
+        message += `Resets in ${relativeTime} (${usage.sonnetOnly.resetTime})\n`;
+      } else {
+        message += `Resets ${usage.sonnetOnly.resetTime}\n`;
+      }
+    }
+  } else {
+    message += 'N/A\n';
+  }
+
+  message += '```';
+  return message;
+}
+
+export default {
+  getClaudeUsageLimits,
+  getProgressBar,
+  calculateTimePassedPercentage,
+  formatUsageMessage
+};