shawnxixi-cli 0.3.0 → 1.1.0

package/src/utils/todo.model.ts

@@ -0,0 +1,167 @@
+/**
+ * Todo Model Utilities
+ * 包含重复规则计算、标签解析、时长格式化等功能
+ */
+
+export type RepeatType = 'none' | 'daily' | 'weekly' | 'monthly';
+
+export interface RepeatRule {
+  type: RepeatType;
+  interval: number; // 重复间隔，如 2 表示每2天/周/月
+  endDate?: string;  // 重复结束日期
+}
+
+/**
+ * 解析重复规则字符串
+ * 格式: "daily", "weekly", "monthly", "2d", "3w", "1m" 等
+ */
+export function parseRepeatRule(rule: string): RepeatRule {
+  if (!rule || rule === 'none') {
+    return { type: 'none', interval: 1 };
+  }
+
+  const lower = rule.toLowerCase();
+
+  if (lower === 'daily') {
+    return { type: 'daily', interval: 1 };
+  }
+  if (lower === 'weekly') {
+    return { type: 'weekly', interval: 1 };
+  }
+  if (lower === 'monthly') {
+    return { type: 'monthly', interval: 1 };
+  }
+
+  // 解析 "2d", "3w", "1m" 格式
+  const match = rule.match(/^(\d+)([dwm])$/i);
+  if (match) {
+    const num = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    switch (unit) {
+      case 'd':
+        return { type: 'daily', interval: num };
+      case 'w':
+        return { type: 'weekly', interval: num };
+      case 'm':
+        return { type: 'monthly', interval: num };
+    }
+  }
+
+  return { type: 'none', interval: 1 };
+}
+
+/**
+ * 计算下一次重复日期
+ */
+export function calculateNextOccurrence(
+  currentDate: Date,
+  rule: RepeatRule
+): Date | null {
+  if (rule.type === 'none') {
+    return null;
+  }
+
+  const next = new Date(currentDate);
+
+  switch (rule.type) {
+    case 'daily':
+      next.setDate(next.getDate() + rule.interval);
+      break;
+    case 'weekly':
+      next.setDate(next.getDate() + 7 * rule.interval);
+      break;
+    case 'monthly':
+      next.setMonth(next.getMonth() + rule.interval);
+      break;
+  }
+
+  // 检查是否超过结束日期
+  if (rule.endDate) {
+    const endDate = new Date(rule.endDate);
+    if (next > endDate) {
+      return null;
+    }
+  }
+
+  return next;
+}
+
+/**
+ * 解析标签字符串
+ * 格式: "work,important,urgent" -> ["work", "important", "urgent"]
+ */
+export function parseTags(tagsString: string | undefined): string[] {
+  if (!tagsString || tagsString.trim() === '') {
+    return [];
+  }
+  return tagsString
+    .split(',')
+    .map(tag => tag.trim())
+    .filter(tag => tag.length > 0);
+}
+
+/**
+ * 格式化时长
+ * 秒数转换为可读格式: "1h30m", "45m", "2h"
+ */
+export function formatDuration(seconds: number): string {
+  if (seconds < 0) {
+    return '0m';
+  }
+
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+
+  if (hours === 0) {
+    return `${minutes}m`;
+  }
+  if (minutes === 0) {
+    return `${hours}h`;
+  }
+  return `${hours}h${minutes}m`;
+}
+
+/**
+ * 解析时长字符串为秒数
+ * 格式: "1h30m", "45m", "2h" -> 秒数
+ */
+export function parseDuration(duration: string): number {
+  const hourMatch = duration.match(/(\d+)h/);
+  const minMatch = duration.match(/(\d+)m/);
+
+  const hours = hourMatch ? parseInt(hourMatch[1], 10) : 0;
+  const minutes = minMatch ? parseInt(minMatch[1], 10) : 0;
+
+  return hours * 3600 + minutes * 60;
+}
+
+export interface TodoItem {
+  id: string;
+  title: string;
+  completed: boolean;
+  priority: 'low' | 'medium' | 'high';
+  dueDate?: string;
+  tags?: string[];
+  repeatRule?: RepeatRule;
+  estimatedDuration?: number; // 秒
+  createdAt: string;
+  completedAt?: string;
+}
+
+/**
+ * 序列化 Todo 为 JSON
+ */
+export function serializeTodo(todo: TodoItem): string {
+  return JSON.stringify(todo);
+}
+
+/**
+ * 反序列化 Todo
+ */
+export function deserializeTodo(json: string): TodoItem | null {
+  try {
+    return JSON.parse(json) as TodoItem;
+  } catch {
+    return null;
+  }
+}

package/tests/commands/finance.test.ts

@@ -0,0 +1,281 @@
+/**
+ * Finance Command Tests
+ * Comprehensive CLI integration tests for biz finance commands
+ */
+
+import { financeCommands } from '../../src/commands/biz/finance';
+import { setGlobalFlags } from '../../src/utils/output';
+
+// Mock apiService
+jest.mock('../../src/services/api', () => ({
+  apiService: {
+    createFinance: jest.fn().mockResolvedValue({ id: 1, amount: 100 }),
+    listFinances: jest.fn().mockResolvedValue({ data: [{ id: 1, amount: 100 }] }),
+    getFinanceStats: jest.fn().mockResolvedValue({ totalIncome: 10000, totalExpense: 5000 }),
+    getFinanceReport: jest.fn().mockResolvedValue({ report: 'test' }),
+  },
+}));
+
+import { apiService } from '../../src/services/api';
+
+// Mock process.exit to prevent test from exiting
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+// Suppress console output during tests
+beforeAll(() => {
+  setGlobalFlags({ quiet: true });
+});
+
+afterAll(() => {
+  setGlobalFlags({ quiet: false });
+  mockExit.mockRestore();
+});
+
+describe('biz finance commands', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('create', () => {
+    it('should call apiService.createFinance with amount only', async () => {
+      await financeCommands.create('100');
+      expect(apiService.createFinance).toHaveBeenCalledWith(
+        100,
+        'income', // positive amounts default to income
+        'other',
+        undefined, // note
+        'cash',    // account default
+        undefined, // date
+        undefined  // tags
+      );
+    });
+
+    it('should call apiService.createFinance with expense type', async () => {
+      await financeCommands.create('100', { type: 'expense' });
+      expect(apiService.createFinance).toHaveBeenCalledWith(
+        100,
+        'expense',
+        'other',
+        undefined,
+        'cash',
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createFinance with income type', async () => {
+      await financeCommands.create('1000', { type: 'income' });
+      expect(apiService.createFinance).toHaveBeenCalledWith(
+        1000,
+        'income',
+        'other',
+        undefined,
+        'cash',
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createFinance with category', async () => {
+      await financeCommands.create('100', { category: 'food' });
+      expect(apiService.createFinance).toHaveBeenCalledWith(
+        100,
+        'income',
+        'food',
+        undefined,
+        'cash',
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createFinance with note', async () => {
+      await financeCommands.create('100', { note: '午饭' });
+      expect(apiService.createFinance).toHaveBeenCalledWith(
+        100,
+        'income',
+        'other',
+        '午饭',
+        'cash',
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createFinance with account', async () => {
+      await financeCommands.create('100', { account: 'bank' });
+      expect(apiService.createFinance).toHaveBeenCalledWith(
+        100,
+        'income',
+        'other',
+        undefined,
+        'bank',
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createFinance with date', async () => {
+      await financeCommands.create('100', { date: '2026-04-01' });
+      expect(apiService.createFinance).toHaveBeenCalledWith(
+        100,
+        'income',
+        'other',
+        undefined,
+        'cash',
+        '2026-04-01',
+        undefined
+      );
+    });
+
+    it('should call apiService.createFinance with tags', async () => {
+      await financeCommands.create('100', { tags: 'food,lunch' });
+      expect(apiService.createFinance).toHaveBeenCalledWith(
+        100,
+        'income',
+        'other',
+        undefined,
+        'cash',
+        undefined,
+        'food,lunch'
+      );
+    });
+
+    it('should call apiService.createFinance with all options', async () => {
+      await financeCommands.create('500', { type: 'income', category: 'salary', note: '月薪', account: 'bank', date: '2026-04-01', tags: 'monthly' });
+      expect(apiService.createFinance).toHaveBeenCalledWith(
+        500,
+        'income',
+        'salary',
+        '月薪',
+        'bank',
+        '2026-04-01',
+        'monthly'
+      );
+    });
+
+    it('should treat negative amounts as expense', async () => {
+      await financeCommands.create('-50');
+      expect(apiService.createFinance).toHaveBeenCalledWith(
+        50,
+        'expense',
+        'other',
+        undefined,
+        'cash',
+        undefined,
+        undefined
+      );
+    });
+
+    it('should reject invalid amount', async () => {
+      await financeCommands.create('invalid');
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.createFinance as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await financeCommands.create('100');
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('list', () => {
+    it('should call apiService.listFinances without filters', async () => {
+      await financeCommands.list();
+      expect(apiService.listFinances).toHaveBeenCalledWith(undefined, undefined, undefined);
+    });
+
+    it('should call apiService.listFinances with type filter', async () => {
+      await financeCommands.list({ type: 'expense' });
+      expect(apiService.listFinances).toHaveBeenCalledWith('expense', undefined, undefined);
+    });
+
+    it('should call apiService.listFinances with category filter', async () => {
+      await financeCommands.list({ category: 'food' });
+      expect(apiService.listFinances).toHaveBeenCalledWith(undefined, 'food', undefined);
+    });
+
+    it('should call apiService.listFinances with month filter', async () => {
+      await financeCommands.list({ month: '2026-04' });
+      expect(apiService.listFinances).toHaveBeenCalledWith(undefined, undefined, '2026-04');
+    });
+
+    it('should call apiService.listFinances with all filters', async () => {
+      await financeCommands.list({ type: 'expense', category: 'food', month: '2026-04' });
+      expect(apiService.listFinances).toHaveBeenCalledWith('expense', 'food', '2026-04');
+    });
+
+    it('should handle empty results', async () => {
+      (apiService.listFinances as jest.Mock).mockResolvedValueOnce({ data: [] });
+
+      await financeCommands.list();
+
+      expect(apiService.listFinances).toHaveBeenCalled();
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.listFinances as jest.Mock).mockRejectedValueOnce(new Error('Network Error'));
+
+      await financeCommands.list();
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('stats', () => {
+    it('should call apiService.getFinanceStats with default month', async () => {
+      const currentMonth = new Date().toISOString().slice(0, 7);
+
+      await financeCommands.stats();
+
+      expect(apiService.getFinanceStats).toHaveBeenCalledWith(currentMonth);
+    });
+
+    it('should call apiService.getFinanceStats with specified month', async () => {
+      await financeCommands.stats({ month: '2026-03' });
+      expect(apiService.getFinanceStats).toHaveBeenCalledWith('2026-03');
+    });
+
+    it('should return stats data', async () => {
+      const stats = { totalIncome: 10000, totalExpense: 5000, netBalance: 5000 };
+      (apiService.getFinanceStats as jest.Mock).mockResolvedValueOnce(stats);
+
+      await financeCommands.stats();
+
+      expect(apiService.getFinanceStats).toHaveBeenCalled();
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.getFinanceStats as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await financeCommands.stats();
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('report', () => {
+    it('should call apiService.getFinanceReport with default month', async () => {
+      const currentMonth = new Date().toISOString().slice(0, 7);
+
+      await financeCommands.report();
+
+      expect(apiService.getFinanceReport).toHaveBeenCalledWith(currentMonth);
+    });
+
+    it('should call apiService.getFinanceReport with specified month', async () => {
+      await financeCommands.report({ month: '2026-03' });
+      expect(apiService.getFinanceReport).toHaveBeenCalledWith('2026-03');
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.getFinanceReport as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await financeCommands.report();
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+});

package/tests/commands/item.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Item Command Tests
+ * Comprehensive CLI integration tests for biz item commands
+ */
+
+import { itemCommands } from '../../src/commands/biz/item';
+import { setGlobalFlags } from '../../src/utils/output';
+
+// Mock apiService
+jest.mock('../../src/services/api', () => ({
+  apiService: {
+    createItem: jest.fn().mockResolvedValue({ id: 1, name: '测试物品' }),
+    listItems: jest.fn().mockResolvedValue({ data: [{ id: 1, name: '测试物品' }] }),
+    getExpiringItems: jest.fn().mockResolvedValue({ data: [] }),
+    getItemStats: jest.fn().mockResolvedValue({ total: 0 }),
+  },
+}));
+
+import { apiService } from '../../src/services/api';
+
+// Mock process.exit to prevent test from exiting
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+// Suppress console output during tests
+beforeAll(() => {
+  setGlobalFlags({ quiet: true });
+});
+
+afterAll(() => {
+  setGlobalFlags({ quiet: false });
+  mockExit.mockRestore();
+});
+
+describe('biz item commands', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('create', () => {
+    it('should call apiService.createItem with name only', async () => {
+      await itemCommands.create('测试物品');
+      expect(apiService.createItem).toHaveBeenCalledWith(
+        '测试物品',
+        undefined, // category
+        undefined, // location
+        undefined, // expire
+        undefined, // quantity
+        undefined, // unit
+        undefined, // brand
+        undefined, // barcode
+        undefined, // price
+        undefined, // supplier
+        undefined  // purchaseDate
+      );
+    });
+
+    it('should call apiService.createItem with category', async () => {
+      await itemCommands.create('测试物品', { category: 'electronics' });
+      expect(apiService.createItem).toHaveBeenCalledWith(
+        '测试物品',
+        'electronics',
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createItem with location', async () => {
+      await itemCommands.create('测试物品', { location: '客厅' });
+      expect(apiService.createItem).toHaveBeenCalledWith(
+        '测试物品',
+        undefined,
+        '客厅',
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createItem with expire date', async () => {
+      await itemCommands.create('测试物品', { expire: '2026-12-31' });
+      expect(apiService.createItem).toHaveBeenCalledWith(
+        '测试物品',
+        undefined,
+        undefined,
+        '2026-12-31',
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createItem with all options', async () => {
+      await itemCommands.create('测试物品', {
+        category: 'electronics',
+        location: '客厅',
+        expire: '2026-12-31',
+        quantity: 2,
+        unit: '个',
+        brand: 'Apple',
+        barcode: '123456789',
+        price: 99.99,
+        supplier: '供应商A',
+        purchaseDate: '2026-01-01',
+      });
+      expect(apiService.createItem).toHaveBeenCalledWith(
+        '测试物品',
+        'electronics',
+        '客厅',
+        '2026-12-31',
+        2,
+        '个',
+        'Apple',
+        '123456789',
+        99.99,
+        '供应商A',
+        '2026-01-01'
+      );
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.createItem as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await itemCommands.create('测试物品');
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('list', () => {
+    it('should call apiService.listItems without filters', async () => {
+      await itemCommands.list();
+      expect(apiService.listItems).toHaveBeenCalledWith(undefined);
+    });
+
+    it('should call apiService.listItems with category filter', async () => {
+      await itemCommands.list({ category: 'electronics' });
+      expect(apiService.listItems).toHaveBeenCalledWith('electronics');
+    });
+
+    it('should handle empty results', async () => {
+      (apiService.listItems as jest.Mock).mockResolvedValueOnce({ data: [] });
+
+      await itemCommands.list();
+
+      expect(apiService.listItems).toHaveBeenCalled();
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.listItems as jest.Mock).mockRejectedValueOnce(new Error('Network Error'));
+
+      await itemCommands.list();
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('expiring', () => {
+    it('should call apiService.getExpiringItems with default days', async () => {
+      await itemCommands.expiring();
+      expect(apiService.getExpiringItems).toHaveBeenCalledWith(7);
+    });
+
+    it('should call apiService.getExpiringItems with custom days', async () => {
+      await itemCommands.expiring({ days: 14 });
+      expect(apiService.getExpiringItems).toHaveBeenCalledWith(14);
+    });
+
+    it('should handle empty results', async () => {
+      (apiService.getExpiringItems as jest.Mock).mockResolvedValueOnce({ data: [] });
+
+      await itemCommands.expiring();
+
+      expect(apiService.getExpiringItems).toHaveBeenCalled();
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.getExpiringItems as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await itemCommands.expiring();
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('stats', () => {
+    it('should call apiService.getItemStats', async () => {
+      await itemCommands.stats();
+      expect(apiService.getItemStats).toHaveBeenCalled();
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.getItemStats as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await itemCommands.stats();
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+});