github-issue-tower-defence-management 2.19.1 → 2.19.3

package/src/adapter/repositories/SqliteClaudeMessageResponseRepository.test.ts

@@ -1,313 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import Database from 'better-sqlite3';
-import {
-  SqliteClaudeMessageResponseRepository,
-  generateUlid,
-} from './SqliteClaudeMessageResponseRepository';
-import { ClaudeMessageResponse } from '../../domain/entities/ClaudeMessageResponse';
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  value !== null && typeof value === 'object' && !Array.isArray(value);
-
-const requireRecord = (value: unknown): Record<string, unknown> => {
-  if (!isRecord(value))
-    throw new Error(`Expected record, got: ${String(value)}`);
-  return value;
-};
-
-const requireRecordArray = (value: unknown[]): Array<Record<string, unknown>> =>
-  value.map(requireRecord);
-
-const buildTestResponse = (
-  overrides: Partial<ClaudeMessageResponse> = {},
-): ClaudeMessageResponse => ({
-  id: generateUlid(),
-  observedAt: new Date('2024-01-15T10:30:00.000Z'),
-  tokenName: 'hashed-token-abc',
-  externalClaudeMessageId: 'msg_01XFDUDYJgAACTvykiHMn8xy',
-  externalClaudeRequestId: 'req_01234',
-  httpStatus: 200,
-  model: 'claude-sonnet-4-5',
-  role: 'assistant',
-  stopReason: 'end_turn',
-  stopSequence: null,
-  inputTokens: 100,
-  outputTokens: 50,
-  cacheCreationInputTokens: null,
-  cacheReadInputTokens: null,
-  ephemeral5mInputTokens: null,
-  ephemeral1hInputTokens: null,
-  serviceTier: 'standard',
-  inferenceGeo: null,
-  errorType: null,
-  errorMessage: null,
-  anthropicRatelimitUnifiedStatus: 'active',
-  anthropicRatelimitUnified5hStatus: 'active',
-  anthropicRatelimitUnified5hUtilization: 42.5,
-  anthropicRatelimitUnified5hReset: 1705316200,
-  anthropicRatelimitUnified7dStatus: 'active',
-  anthropicRatelimitUnified7dUtilization: 10.0,
-  anthropicRatelimitUnified7dReset: 1705920000,
-  retryAfter: null,
-  anthropicOrganizationId: 'org-abc123',
-  ...overrides,
-});
-
-describe('generateUlid', () => {
-  it('generates a 26-character uppercase alphanumeric string', () => {
-    const ulid = generateUlid();
-    expect(ulid).toHaveLength(26);
-    expect(/^[0-9A-HJKMNP-TV-Z]{26}$/.test(ulid)).toBe(true);
-  });
-
-  it('generates unique values across multiple calls', () => {
-    const ids = new Set(Array.from({ length: 100 }, () => generateUlid()));
-    expect(ids.size).toBe(100);
-  });
-
-  it('generates a value whose first 10 characters encode a timestamp no later than the current time', () => {
-    const before = Date.now();
-    const ulid = generateUlid();
-    const after = Date.now();
-    const ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
-    const timeChars = ulid.slice(0, 10);
-    let decoded = 0;
-    for (const char of timeChars) {
-      decoded = decoded * 32 + ENCODING.indexOf(char);
-    }
-    expect(decoded).toBeGreaterThanOrEqual(before);
-    expect(decoded).toBeLessThanOrEqual(after);
-  });
-});
-
-describe('SqliteClaudeMessageResponseRepository', () => {
-  let tmpDir: string;
-  let dbPath: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-msg-repo-test-'));
-    dbPath = path.join(tmpDir, 'claude_message_response.db');
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  describe('constructor', () => {
-    it('creates the database file when it does not exist', () => {
-      new SqliteClaudeMessageResponseRepository(dbPath);
-      expect(fs.existsSync(dbPath)).toBe(true);
-    });
-
-    it('creates the parent directory when it does not exist', () => {
-      const nestedDbPath = path.join(tmpDir, 'nested', 'dir', 'test.db');
-      new SqliteClaudeMessageResponseRepository(nestedDbPath);
-      expect(fs.existsSync(nestedDbPath)).toBe(true);
-    });
-
-    it('creates the claude_message_response table on first open', () => {
-      new SqliteClaudeMessageResponseRepository(dbPath);
-      const db = new Database(dbPath);
-      const row = db
-        .prepare(
-          "SELECT name FROM sqlite_master WHERE type='table' AND name='claude_message_response'",
-        )
-        .get();
-      db.close();
-      expect(row).toBeDefined();
-    });
-
-    it('does not fail when reopened against an existing database', () => {
-      new SqliteClaudeMessageResponseRepository(dbPath);
-      expect(() => {
-        new SqliteClaudeMessageResponseRepository(dbPath);
-      }).not.toThrow();
-    });
-  });
-
-  describe('append', () => {
-    it('inserts a row with all fields set', () => {
-      const repo = new SqliteClaudeMessageResponseRepository(dbPath);
-      const response = buildTestResponse();
-
-      repo.append(response);
-
-      const db = new Database(dbPath);
-      const row = requireRecord(
-        db
-          .prepare('SELECT * FROM claude_message_response WHERE id = ?')
-          .get(response.id),
-      );
-      db.close();
-
-      expect(row['id']).toBe(response.id);
-      expect(row['observed_at']).toBe(response.observedAt.getTime());
-      expect(row['token_name']).toBe(response.tokenName);
-      expect(row['external_claude_message_id']).toBe(
-        response.externalClaudeMessageId,
-      );
-      expect(row['external_claude_request_id']).toBe(
-        response.externalClaudeRequestId,
-      );
-      expect(row['http_status']).toBe(response.httpStatus);
-      expect(row['model']).toBe(response.model);
-      expect(row['role']).toBe(response.role);
-      expect(row['stop_reason']).toBe(response.stopReason);
-      expect(row['stop_sequence']).toBeNull();
-      expect(row['input_tokens']).toBe(response.inputTokens);
-      expect(row['output_tokens']).toBe(response.outputTokens);
-      expect(row['cache_creation_input_tokens']).toBeNull();
-      expect(row['cache_read_input_tokens']).toBeNull();
-      expect(row['ephemeral_5m_input_tokens']).toBeNull();
-      expect(row['ephemeral_1h_input_tokens']).toBeNull();
-      expect(row['service_tier']).toBe(response.serviceTier);
-      expect(row['inference_geo']).toBeNull();
-      expect(row['error_type']).toBeNull();
-      expect(row['error_message']).toBeNull();
-      expect(row['anthropic_ratelimit_unified_status']).toBe(
-        response.anthropicRatelimitUnifiedStatus,
-      );
-      expect(row['anthropic_ratelimit_unified_5h_status']).toBe(
-        response.anthropicRatelimitUnified5hStatus,
-      );
-      expect(row['anthropic_ratelimit_unified_5h_utilization']).toBe(
-        response.anthropicRatelimitUnified5hUtilization,
-      );
-      expect(row['anthropic_ratelimit_unified_5h_reset']).toBe(
-        response.anthropicRatelimitUnified5hReset,
-      );
-      expect(row['anthropic_ratelimit_unified_7d_status']).toBe(
-        response.anthropicRatelimitUnified7dStatus,
-      );
-      expect(row['anthropic_ratelimit_unified_7d_utilization']).toBe(
-        response.anthropicRatelimitUnified7dUtilization,
-      );
-      expect(row['anthropic_ratelimit_unified_7d_reset']).toBe(
-        response.anthropicRatelimitUnified7dReset,
-      );
-      expect(row['retry_after']).toBeNull();
-      expect(row['anthropic_organization_id']).toBe(
-        response.anthropicOrganizationId,
-      );
-    });
-
-    it('inserts a row where all nullable fields are null', () => {
-      const repo = new SqliteClaudeMessageResponseRepository(dbPath);
-      const response = buildTestResponse({
-        externalClaudeMessageId: null,
-        externalClaudeRequestId: null,
-        model: null,
-        role: null,
-        stopReason: null,
-        stopSequence: null,
-        inputTokens: null,
-        outputTokens: null,
-        cacheCreationInputTokens: null,
-        cacheReadInputTokens: null,
-        ephemeral5mInputTokens: null,
-        ephemeral1hInputTokens: null,
-        serviceTier: null,
-        inferenceGeo: null,
-        errorType: null,
-        errorMessage: null,
-        anthropicRatelimitUnifiedStatus: null,
-        anthropicRatelimitUnified5hStatus: null,
-        anthropicRatelimitUnified5hUtilization: null,
-        anthropicRatelimitUnified5hReset: null,
-        anthropicRatelimitUnified7dStatus: null,
-        anthropicRatelimitUnified7dUtilization: null,
-        anthropicRatelimitUnified7dReset: null,
-        retryAfter: null,
-        anthropicOrganizationId: null,
-      });
-
-      repo.append(response);
-
-      const db = new Database(dbPath);
-      const row = requireRecord(
-        db
-          .prepare('SELECT * FROM claude_message_response WHERE id = ?')
-          .get(response.id),
-      );
-      db.close();
-
-      expect(row['id']).toBe(response.id);
-      expect(row['http_status']).toBe(response.httpStatus);
-      expect(row['external_claude_message_id']).toBeNull();
-      expect(row['model']).toBeNull();
-    });
-
-    it('inserts an error response with error fields set', () => {
-      const repo = new SqliteClaudeMessageResponseRepository(dbPath);
-      const response = buildTestResponse({
-        httpStatus: 429,
-        model: null,
-        role: null,
-        stopReason: null,
-        inputTokens: null,
-        outputTokens: null,
-        errorType: 'rate_limit_error',
-        errorMessage: 'Too many requests',
-        retryAfter: 30,
-      });
-
-      repo.append(response);
-
-      const db = new Database(dbPath);
-      const row = requireRecord(
-        db
-          .prepare('SELECT * FROM claude_message_response WHERE id = ?')
-          .get(response.id),
-      );
-      db.close();
-
-      expect(row['http_status']).toBe(429);
-      expect(row['error_type']).toBe('rate_limit_error');
-      expect(row['error_message']).toBe('Too many requests');
-      expect(row['retry_after']).toBe(30);
-    });
-
-    it('inserts multiple rows appending each independently', () => {
-      const repo = new SqliteClaudeMessageResponseRepository(dbPath);
-      const responses = [
-        buildTestResponse({ httpStatus: 200 }),
-        buildTestResponse({ httpStatus: 429 }),
-        buildTestResponse({ httpStatus: 200 }),
-      ];
-
-      for (const response of responses) {
-        repo.append(response);
-      }
-
-      const db = new Database(dbPath);
-      const rows = requireRecordArray(
-        db.prepare('SELECT id FROM claude_message_response').all(),
-      );
-      db.close();
-
-      expect(rows).toHaveLength(3);
-      const rowIds = rows.map((r) => r['id']).sort();
-      const responseIds = responses.map((r) => r.id).sort();
-      expect(rowIds).toEqual(responseIds);
-    });
-
-    it('persists rows that survive a repository close and reopen', () => {
-      const firstRepo = new SqliteClaudeMessageResponseRepository(dbPath);
-      const response = buildTestResponse();
-      firstRepo.append(response);
-
-      const secondRepo = new SqliteClaudeMessageResponseRepository(dbPath);
-
-      const db = new Database(dbPath);
-      const countRow = requireRecord(
-        db.prepare('SELECT COUNT(*) as cnt FROM claude_message_response').get(),
-      );
-      db.close();
-
-      expect(countRow['cnt']).toBe(1);
-      expect(secondRepo).toBeDefined();
-    });
-  });
-});

package/src/adapter/repositories/SqliteClaudeMessageResponseRepository.ts

@@ -1,164 +0,0 @@
-import * as crypto from 'crypto';
-import Database from 'better-sqlite3';
-import * as fs from 'fs';
-import * as path from 'path';
-import { ClaudeMessageResponse } from '../../domain/entities/ClaudeMessageResponse';
-import { ClaudeMessageResponseRepository } from '../../domain/usecases/adapter-interfaces/ClaudeMessageResponseRepository';
-
-const ULID_ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
-
-const encodeUlidTime = (ms: number): string => {
-  let str = '';
-  for (let i = 9; i >= 0; i--) {
-    str = ULID_ENCODING[ms % 32] + str;
-    ms = Math.floor(ms / 32);
-  }
-  return str;
-};
-
-const encodeUlidRandom = (): string => {
-  const bytes = crypto.randomBytes(10);
-  let bits = 0;
-  let bitLen = 0;
-  let str = '';
-  for (let i = 0; i < bytes.length && str.length < 16; i++) {
-    bits = (bits << 8) | bytes[i];
-    bitLen += 8;
-    while (bitLen >= 5 && str.length < 16) {
-      str += ULID_ENCODING[(bits >>> (bitLen - 5)) & 0x1f];
-      bitLen -= 5;
-    }
-  }
-  return str;
-};
-
-export const generateUlid = (): string =>
-  encodeUlidTime(Date.now()) + encodeUlidRandom();
-
-const CREATE_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS claude_message_response (
-    id TEXT PRIMARY KEY,
-    observed_at INTEGER NOT NULL,
-    token_name TEXT NOT NULL,
-    external_claude_message_id TEXT,
-    external_claude_request_id TEXT,
-    http_status INTEGER NOT NULL,
-    model TEXT,
-    role TEXT,
-    stop_reason TEXT,
-    stop_sequence TEXT,
-    input_tokens INTEGER,
-    output_tokens INTEGER,
-    cache_creation_input_tokens INTEGER,
-    cache_read_input_tokens INTEGER,
-    ephemeral_5m_input_tokens INTEGER,
-    ephemeral_1h_input_tokens INTEGER,
-    service_tier TEXT,
-    inference_geo TEXT,
-    error_type TEXT,
-    error_message TEXT,
-    anthropic_ratelimit_unified_status TEXT,
-    anthropic_ratelimit_unified_5h_status TEXT,
-    anthropic_ratelimit_unified_5h_utilization REAL,
-    anthropic_ratelimit_unified_5h_reset REAL,
-    anthropic_ratelimit_unified_7d_status TEXT,
-    anthropic_ratelimit_unified_7d_utilization REAL,
-    anthropic_ratelimit_unified_7d_reset REAL,
-    retry_after REAL,
-    anthropic_organization_id TEXT
-  ) STRICT
-`;
-
-const INSERT_SQL = `
-  INSERT INTO claude_message_response (
-    id, observed_at, token_name,
-    external_claude_message_id, external_claude_request_id,
-    http_status, model, role, stop_reason, stop_sequence,
-    input_tokens, output_tokens,
-    cache_creation_input_tokens, cache_read_input_tokens,
-    ephemeral_5m_input_tokens, ephemeral_1h_input_tokens,
-    service_tier, inference_geo,
-    error_type, error_message,
-    anthropic_ratelimit_unified_status,
-    anthropic_ratelimit_unified_5h_status,
-    anthropic_ratelimit_unified_5h_utilization,
-    anthropic_ratelimit_unified_5h_reset,
-    anthropic_ratelimit_unified_7d_status,
-    anthropic_ratelimit_unified_7d_utilization,
-    anthropic_ratelimit_unified_7d_reset,
-    retry_after, anthropic_organization_id
-  ) VALUES (
-    @id, @observedAt, @tokenName,
-    @externalClaudeMessageId, @externalClaudeRequestId,
-    @httpStatus, @model, @role, @stopReason, @stopSequence,
-    @inputTokens, @outputTokens,
-    @cacheCreationInputTokens, @cacheReadInputTokens,
-    @ephemeral5mInputTokens, @ephemeral1hInputTokens,
-    @serviceTier, @inferenceGeo,
-    @errorType, @errorMessage,
-    @anthropicRatelimitUnifiedStatus,
-    @anthropicRatelimitUnified5hStatus,
-    @anthropicRatelimitUnified5hUtilization,
-    @anthropicRatelimitUnified5hReset,
-    @anthropicRatelimitUnified7dStatus,
-    @anthropicRatelimitUnified7dUtilization,
-    @anthropicRatelimitUnified7dReset,
-    @retryAfter, @anthropicOrganizationId
-  )
-`;
-
-export class SqliteClaudeMessageResponseRepository implements ClaudeMessageResponseRepository {
-  private readonly db: Database.Database;
-  private readonly insert: Database.Statement;
-
-  constructor(dbPath: string) {
-    const dir = path.dirname(dbPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    this.db = new Database(dbPath);
-    this.db.pragma('journal_mode = WAL');
-    this.db.exec(CREATE_TABLE_SQL);
-    this.insert = this.db.prepare(INSERT_SQL);
-  }
-
-  append = (response: ClaudeMessageResponse): void => {
-    this.insert.run({
-      id: response.id,
-      observedAt: response.observedAt.getTime(),
-      tokenName: response.tokenName,
-      externalClaudeMessageId: response.externalClaudeMessageId,
-      externalClaudeRequestId: response.externalClaudeRequestId,
-      httpStatus: response.httpStatus,
-      model: response.model,
-      role: response.role,
-      stopReason: response.stopReason,
-      stopSequence: response.stopSequence,
-      inputTokens: response.inputTokens,
-      outputTokens: response.outputTokens,
-      cacheCreationInputTokens: response.cacheCreationInputTokens,
-      cacheReadInputTokens: response.cacheReadInputTokens,
-      ephemeral5mInputTokens: response.ephemeral5mInputTokens,
-      ephemeral1hInputTokens: response.ephemeral1hInputTokens,
-      serviceTier: response.serviceTier,
-      inferenceGeo: response.inferenceGeo,
-      errorType: response.errorType,
-      errorMessage: response.errorMessage,
-      anthropicRatelimitUnifiedStatus: response.anthropicRatelimitUnifiedStatus,
-      anthropicRatelimitUnified5hStatus:
-        response.anthropicRatelimitUnified5hStatus,
-      anthropicRatelimitUnified5hUtilization:
-        response.anthropicRatelimitUnified5hUtilization,
-      anthropicRatelimitUnified5hReset:
-        response.anthropicRatelimitUnified5hReset,
-      anthropicRatelimitUnified7dStatus:
-        response.anthropicRatelimitUnified7dStatus,
-      anthropicRatelimitUnified7dUtilization:
-        response.anthropicRatelimitUnified7dUtilization,
-      anthropicRatelimitUnified7dReset:
-        response.anthropicRatelimitUnified7dReset,
-      retryAfter: response.retryAfter,
-      anthropicOrganizationId: response.anthropicOrganizationId,
-    });
-  };
-}

package/src/adapter/repositories/SystemDateRepository.test.ts

@@ -1,60 +0,0 @@
-import { SystemDateRepository } from './SystemDateRepository';
-
-describe('SystemDateRepository', () => {
-  const repo = new SystemDateRepository();
-
-  const jan15At09h05 = new Date(Date.UTC(2026, 0, 15, 9, 5, 0));
-  const jan15At10h30 = new Date(Date.UTC(2026, 0, 15, 10, 30, 0));
-  const jan16At08h00 = new Date(Date.UTC(2026, 0, 16, 8, 0, 0));
-
-  describe('formatDurationToHHMM', () => {
-    it('formats whole hours', () => {
-      expect(repo.formatDurationToHHMM(120)).toBe('02:00');
-    });
-
-    it('formats hours and minutes', () => {
-      expect(repo.formatDurationToHHMM(90)).toBe('01:30');
-    });
-
-    it('formats minutes only', () => {
-      expect(repo.formatDurationToHHMM(5)).toBe('00:05');
-    });
-  });
-
-  describe('formatDateWithDayOfWeek', () => {
-    it('formats a UTC date with day-of-week in YYYY/MM/DD (Day) form', () => {
-      expect(repo.formatDateWithDayOfWeek(jan15At09h05)).toBe(
-        '2026/01/15 (Thu)',
-      );
-    });
-  });
-
-  describe('formatDateTimeWithDayOfWeek', () => {
-    it('appends UTC HH:MM to the date-with-day-of-week', () => {
-      expect(repo.formatDateTimeWithDayOfWeek(jan15At09h05)).toBe(
-        '2026/01/15 (Thu) 09:05',
-      );
-    });
-
-    it('pads single-digit hour and minute', () => {
-      const date = new Date(Date.UTC(2026, 2, 3, 4, 7, 0));
-      expect(repo.formatDateTimeWithDayOfWeek(date)).toBe(
-        '2026/03/03 (Tue) 04:07',
-      );
-    });
-  });
-
-  describe('formatStartEnd', () => {
-    it('omits the date for same-day end', () => {
-      expect(repo.formatStartEnd(jan15At09h05, jan15At10h30)).toBe(
-        '2026/01/15 (Thu) 09:05 - 10:30',
-      );
-    });
-
-    it('includes full date-time for end on a different day', () => {
-      expect(repo.formatStartEnd(jan15At09h05, jan16At08h00)).toBe(
-        '2026/01/15 (Thu) 09:05 - 2026/01/16 (Fri) 08:00',
-      );
-    });
-  });
-});

package/src/adapter/repositories/SystemDateRepository.ts

@@ -1,34 +0,0 @@
-import { DateRepository } from '../../domain/usecases/adapter-interfaces/DateRepository';
-
-export class SystemDateRepository implements DateRepository {
-  now = async () => new Date();
-  formatDurationToHHMM = (durationMinutes: number): string => {
-    const hours = Math.floor(durationMinutes / 60);
-    const minutes = Math.floor(durationMinutes % 60);
-    return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`;
-  };
-  formatDateTimeWithDayOfWeek = (date: Date): string => {
-    const dateWithDayOfWeek = this.formatDateWithDayOfWeek(date);
-    const hours = String(date.getUTCHours()).padStart(2, '0');
-    const minutes = String(date.getUTCMinutes()).padStart(2, '0');
-    return `${dateWithDayOfWeek} ${hours}:${minutes}`;
-  };
-
-  formatDateWithDayOfWeek = (date: Date): string => {
-    const dayOfWeek = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][
-      date.getUTCDay()
-    ];
-    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
-    const day = String(date.getUTCDate()).padStart(2, '0');
-    return `${date.getUTCFullYear()}/${month}/${day} (${dayOfWeek})`;
-  };
-  formatStartEnd = (start: Date, end: Date): string => {
-    const endDate =
-      start.getUTCFullYear() === end.getUTCFullYear() &&
-      start.getUTCMonth() === end.getUTCMonth() &&
-      start.getUTCDate() === end.getUTCDate()
-        ? `${String(end.getUTCHours()).padStart(2, '0')}:${String(end.getUTCMinutes()).padStart(2, '0')}`
-        : this.formatDateTimeWithDayOfWeek(end);
-    return `${this.formatDateTimeWithDayOfWeek(start)} - ${endDate}`;
-  };
-}