别再一个个窗口切换了！CodexBar 把 AI 编程助手塞进菜单栏，效率直接翻倍

# 添加 CodexBar 的官方 Tap（如果存在）
brew tap steipete/codexbar

# 安装 CodexBar
brew install --cask codexbar

https://github.com/steipete/CodexBar/releases

# 克隆仓库
git clone https://github.com/steipete/CodexBar.git

# 进入项目目录
cd CodexBar

# 使用 Xcode 打开项目
open CodexBar.xcodeproj

# 在 Xcode 中选择 Product > Build (Cmd + B)
# 然后选择 Product > Run (Cmd + R)

# 打开项目文件
> open file [文件名]

# 搜索代码片段
> search [关键词]

# 插入代码模板
> snippet [模板名]

# 翻译代码
> translate [语言]

# 解释选中代码
> explain

# 生成单元测试
> test generate

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

# 假设你保存了一个名为 "python-logger" 的片段
> snippet insert python-logger
# 选中的片段内容会被复制到剪贴板，或直接粘贴到当前焦点应用

# 这是一个带变量的 Python 函数模板
def ${1:func_name}(${2:params}):
    """${3:docstring}"""
    ${4:pass}
    return ${5:result}

# 查询 Python 列表方法
> docs list python

# 查询 React Hooks
> docs useState react

# 查询 Swift 闭包语法
> docs closure swift

> /model gpt-4
> 帮我重构这段代码...

import hashlib
import hmac
import time
from typing import Dict, Optional

class WebhookValidator:
    def __init__(self, secret: str):
        self.secret = secret.encode('utf-8')

    def compute_signature(self, payload: str, timestamp: str) -> str:
        signed_payload = f"{timestamp}.{payload}"
        signature = hmac.new(
            self.secret,
            signed_payload.encode('utf-8'),
            hashlib.sha256
        ).hexdigest()
        return f"sha256={signature}"

    def verify(self, payload: str, timestamp: str, signature: str) -> bool:
        computed = self.compute_signature(payload, timestamp)
        return hmac.compare_digest(computed, signature)

    def is_expired(self, timestamp: str, max_age: int = 300) -> bool:
        try:
            current_time = int(time.time())
            payload_time = int(timestamp)
            return (current_time - payload_time) > max_age
        except ValueError:
            return True

> explain

这段代码实现了一个 Webhook 签名验证器，用于确保 Webhook 请求来自可信来源且未被篡改。

核心功能：
1. compute_signature：计算 HMAC-SHA256 签名
   - 使用时间戳 + 原始载荷拼接后的字符串进行签名
   - 返回格式为 "sha256={hex}" 的签名字符串

2. verify：验证请求的签名是否合法
   - 使用 hmac.compare_digest 进行恒定时间比较，防止时序攻击

3. is_expired：检查请求是否已过期
   - 默认超时时间为 300 秒（5 分钟）
   - 用于防止重放攻击

安全最佳实践：
- 使用 hmac.compare_digest 而非 == 比较签名
- 时间戳与签名结合防止重放攻击
- 编码明确指定为 UTF-8

def parse_config(config_str: str) -> Dict[str, any]:
    """
    解析配置文件字符串。

    支持的格式：
    - key=value
    - key="value with spaces"
    - key='single quotes'
    - # 注释行会被忽略
    """
    result = {}
    for line in config_str.split('\n'):
        line = line.strip()
        if not line or line.startswith('#'):
            continue
        if '=' in line:
            key, value = line.split('=', 1)
            key = key.strip()
            value = value.strip().strip('"').strip("'")
            result[key] = value
    return result

> test generate

> pytest

import pytest
from your_module import parse_config


class TestParseConfig:
    """parse_config 函数的单元测试"""

    def test_basic_key_value(self):
        """测试基本的 key=value 格式"""
        config_str = "host=localhost\nport=8080"
        result = parse_config(config_str)
        assert result == {"host": "localhost", "port": "8080"}

    def test_value_with_spaces_double_quotes(self):
        """测试带空格的值（双引号）"""
        config_str = 'greeting="Hello World"'
        result = parse_config(config_str)
        assert result == {"greeting": "Hello World"}

    def test_value_with_spaces_single_quotes(self):
        """测试带空格的值（单引号）"""
        config_str = "message='Hello World'"
        result = parse_config(config_str)
        assert result == {"message": "Hello World"}

    def test_ignore_comments(self):
        """测试忽略注释行"""
        config_str = "# 这是一行注释\nhost=localhost\n# 另一行注释"
        result = parse_config(config_str)
        assert result == {"host": "localhost"}

    def test_empty_lines_ignored(self):
        """测试忽略空行"""
        config_str = "host=localhost\n\n\nport=8080\n"
        result = parse_config(config_str)
        assert result == {"host": "localhost", "port": "8080"}

    def test_empty_config(self):
        """测试空配置"""
        result = parse_config("")
        assert result == {}

    def test_only_comments(self):
        """测试只有注释的配置"""
        config_str = "# 注释1\n# 注释2"
        result = parse_config(config_str)
        assert result == {}

    def test_value_with_equals_in_value(self):
        """测试值中包含等号的情况"""
        config_str = "equation=a=b=c"
        result = parse_config(config_str)
        assert result == {"equation": "b=c"}

from datetime import datetime, timedelta
from typing import List, Dict

def calculate_date_range(start_date: str, days: int) -> List[str]:
    """
    计算日期范围，返回从开始日期往后指定天数的日期列表。

    Args:
        start_date: 起始日期，格式为 YYYY-MM-DD
        days: 天数

    Returns:
        日期字符串列表
    """
    start = datetime.strptime(start_date, "%Y-%m-%d")
    end = start + timedelta(days=days)

    result = []
    current = start
    while current <= end:
        result.append(current.strftime("%Y-%m-%d"))
        current += timedelta(days=1)

    return result

def aggregate_by_month(data: List[Dict]) -> Dict[str, float]:
    """按月份聚合数据"""
    monthly = {}
    for item in data:
        date = datetime.strptime(item['date'], "%Y-%m-%d")
        month_key = date.strftime("%Y-%m")
        monthly[month_key] = monthly.get(month_key, 0) + item['value']
    return monthly

> translate javascript

> TypeScript

/**
 * 计算日期范围，返回从开始日期往后指定天数的日期列表。
 *
 * @param startDate - 起始日期，格式为 YYYY-MM-DD
 * @param days - 天数
 *
 * @returns 日期字符串数组
 */
function calculateDateRange(startDate: string, days: number): string[] {
    const start = new Date(startDate);
    const end = new Date(start);
    end.setDate(end.getDate() + days);

    const result: string[] = [];
    const current = new Date(start);

    while (current <= end) {
        result.push(current.toISOString().split('T')[0]);
        current.setDate(current.getDate() + 1);
    }

    return result;
}

/**
 * 按月份聚合数据
 */
function aggregateByMonth(data: Array<{date: string; value: number}>): Record<string, number> {
    const monthly: Record<string, number> = {};

    for (const item of data) {
        const date = new Date(item.date);
        const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
        monthly[monthKey] = (monthly[monthKey] || 0) + item.value;
    }

    return monthly;
}

> docs Date javascript

JavaScript Date 对象常用方法速查
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

创建 Date 实例：
const now = new Date();
const specific = new Date('2024-01-15');
const fromTimestamp = new Date(1705315200000);

获取方法（get*）：
now.getFullYear()      // 返回四位数年份
now.getMonth()         // 返回 0-11 的月份
now.getDate()          // 返回 1-31 的日期
now.getHours()         // 返回 0-23 的小时
now.getMinutes()       // 返回 0-59 的分钟
now.getSeconds()       // 返回 0-59 的秒数
now.getDay()           // 返回 0-6 的星期几
now.getTime()          // 返回时间戳（毫秒）

设置方法（set*）：
now.setFullYear(2025)
now.setMonth(5)        // 设置为六月（0-11）
now.setDate(20)
now.setHours(12)

格式化相关：
now.toISOString()      // "2024-01-15T00:00:00.000Z"
now.toLocaleDateString() // 本地化日期
now.toLocaleTimeString() // 本地化时间

实用技巧：
// 计算日期间隔
const diff = date2.getTime() - date1.getTime();
const days = Math.floor(diff / (1000 * 60 * 60 * 24));

// 检查是否为有效日期
!isNaN(date.getTime())

[在浏览器中打开 MDN 文档]

import json

def process_orders(orders):
    """处理订单列表，计算每个客户的总消费"""
    result = []
    for order in orders:
        customer_name = order['customer']
        order_total = sum(item['price'] * item['quantity'] 
                          for item in order['items'])
        result.append({
            'customer': customer_name,
            'total': order_total
        })
    return result

def find_top_customers(orders, top_n=10):
    """找出消费最高的前 N 位客户"""
    processed = process_orders(orders)
    # 按总消费排序
    sorted_orders = sorted(processed, 
                          key=lambda x: x['total'], 
                          reverse=True)
    return sorted_orders[:top_n]

def generate_report(orders, filename):
    """生成 JSON 格式的报告"""
    top = find_top_customers(orders)
    with open(filename, 'w') as f:
        json.dump(top, f, indent=2)

> refactor optimize

import json
from collections import defaultdict

def process_orders(orders):
    """
    处理订单列表，计算每个客户的总消费
    使用单次遍历 + 字典聚合，O(n) 复杂度
    """
    customer_totals = defaultdict(float)

    for order in orders:
        customer_name = order['customer']
        order_total = sum(item['price'] * item['quantity'] 
                          for item in order['items'])
        customer_totals[customer_name] += order_total

    return [{'customer': name, 'total': total} 
            for name, total in customer_totals.items()]

def find_top_customers(orders, top_n=10):
    """
    找出消费最高的前 N 位客户
    使用 heapq 实现高效 top-k 查询
    """
    # 使用 Counter 一次性聚合（更简洁）
    from collections import Counter

    totals = Counter()
    for order in orders:
        customer = order['customer']
        order_total = sum(item['price'] * item['quantity'] 
                          for item in order['items'])
        totals[customer] += order_total

    # heapq.nlargest 比完整排序更高效
    import heapq
    return heapq.nlargest(top_n, totals.items(), key=lambda x: x[1])

def generate_report(orders, filename):
    """
    生成 JSON 格式的报告
    支持生成器模式减少内存占用
    """
    def order_generator():
        for order in orders:
            yield {
                'customer': order['customer'],
                'total': sum(item['price'] * item['quantity'] 
                            for item in order['items'])
            }

    top = find_top_customers(orders)
    with open(filename, 'w') as f:
        json.dump(top, f, indent=2)

CodexBar 优化建议
━━━━━━━━━━━━━━━━━

1. process_orders 函数：
   - 原实现：O(n*m) 其中 n 是订单数，m 是平均商品数
   - 新实现：O(n) 单次遍历，使用 defaultdict 避免键检查

2. find_top_customers 函数：
   - 原实现：先完整处理，再完整排序，O(n log n)
   - 新实现：使用 Counter + heapq.nlargest，O(n log k)
   - 当 k << n 时，性能提升显著

3. 内存优化：
   - 使用生成器模式避免一次性加载所有数据
   - 适合处理超大数据集

性能预估：
- 1000 条订单：提升约 30%
- 10000 条订单：提升约 60%
- 100000 条订单：提升约 85%

# 1. 保存常用模板
> snippet save
  名称: react-class-component
  内容: 
  class ${1:ComponentName} extends React.Component {
    constructor(props) {
      super(props);
      this.state = { ${2:state}: ${3:value} };
    }

    render() {
      return (
        <div>
          ${4:// TODO}
        </div>
      );
    }
  }
  export default ${1};

# 2. 快速插入
> snippet react-class-component
# 代码被复制到剪贴板或直接粘贴到当前应用

# Python 调试日志
> snippet python-debug-log
# 生成：
print(f"[DEBUG] {func_name}: {var_name}={var_value}")

# JavaScript 调试日志
> snippet js-debug-log
# 生成：
console.log('[DEBUG]', { ${1:variableName} });

# Swift 调试日志
> snippet swift-debug-log
# 生成：
print("[DEBUG] \(#function): \(${1:variableName})")

# 查看项目结构
> project structure

# 搜索某个功能的相关代码
> search "用户认证" in:project

# 查看某个模块的依赖关系
> deps auth/users

# 找出某个函数的调用链
> trace processPayment

# 为当前项目设置上下文
> context set project-frontend
> 启用 React + TypeScript + Vite 上下文

# 快速切换上下文
> context switch backend
> 切换到 Python + Django + PostgreSQL 上下文

# 查看当前上下文
> context current
> 项目：backend-api (Django)

# 直接提问
> 如何在 Python 中实现单例模式？

# 针对特定场景提问
> 解释 React useEffect 的依赖数组空数组和不传的区别

# 查找最佳实践
> Django REST Framework 分页的最佳实践

# 解决错误
> TypeError: 'NoneType' object is not iterable 怎么解决？

# 这些都能匹配 "snippet insert"
> snip ins
> snippet insert python-logger
> sni insert py-log
> sni py

// 在配置文件中添加自定义命令
{
  "customCommands": [
    {
      "name": "快速提交",
      "trigger": "gc",
      "actions": [
        {"type": "shell", "command": "git add -A"},
        {"type": "prompt", "text": "输入提交信息"},
        {"type": "shell", "command": "git commit -m {input}"}
      ]
    },
    {
      "name": "运行测试",
      "trigger": "test",
      "actions": [
        {"type": "detect", "framework": "jest|pytest|npm test"},
        {"type": "shell", "command": "{detected_framework} --coverage"}
      ]
    }
  ]
}

# 常用模板变量
${1:default_value}  # Tab 跳转位置，带默认值
${2:placeholder}    # 另一个跳转位置
$CLIPBOARD          # 粘贴板内容
$CURRENT_DATE       # 当前日期
$CURRENT_TIME       # 当前时间
$SELECTION          # 选中的文本
$PROJECT_NAME       # 当前项目名
$FILE_PATH          # 当前文件路径

# 场景：快速翻译选中的代码
# 1. 在系统偏好设置中添加全局快捷键（如 Cmd+Shift+T）
# 2. 在 CodexBar 中配置该快捷键的行为：
{
  "shortcuts": {
    "⌘⇧T": "translate auto:中文"
  }
}

# 场景：快速打开最近项目
{
  "shortcuts": {
    "⌘⇧P": "project recent"
  }
}

# 在 ~/.zshrc 或 ~/.bashrc 中添加
export CODEXBAR_OPENAI_KEY="sk-..."

# 在 CodexBar 配置中引用
{
  "apiProviders": {
    "openai": {
      "keyEnv": "CODEXBAR_OPENAI_KEY"
    }
  }
}

# 手动重建索引
> index rebuild

# 排除不需要索引的目录
# 在 .codexbarignore 文件中配置
node_modules/
dist/
build/
__pycache__/
*.pyc
.vscode/
.idea/
coverage/

早上：
1. 启动 CodexBar，确认上下文环境正确
2. > context show  # 确认当前项目和语言设置

工作中：
3. 遇到问题先在 CodexBar 搜索
4. 频繁使用的功能配置快捷键
5. 定期保存代码片段

下班前：
6. > snippet save-recent  # 保存今天常用的片段
7. 清理不需要的对话历史