ccwarm-temp 1.0.0 → 1.0.1

package/README.md

@@ -2,15 +2,19 @@
 
 Optimize your Claude Code rate limit window by pre-warming sessions based on your usage patterns.
 
+> **Note:** This tool is for **Claude Pro and Max** subscribers, not for API-based usage.
+
 ## The Problem
 
-Claude Code's rate limits reset 5 hours after your **first message**. If you start working at 9:00 and work for 4 hours, your limit resets at 14:00 - right when you might need it.
+Claude Code's rate limits reset 5 hours after your **first message**.
 
 ## The Solution
 
-ccwarm analyzes your usage history to find when you typically work. It then sends a "hi" message before you start, so your rate limit resets when you actually need it.
+ccwarm analyzes your usage history to find when you typically work. It then sends a short message to Claude Code at the optimal time, so your rate limit resets when you actually need it.
+
+### Example
 
-**Example:** You work 9:00-13:30 → ccwarm sends "hi" at 7:15 → limit resets at 12:15 instead of 14:00
+You typically work 9:00-13:30 and get blocked in the middle → ccwarm sends "hi" at 7:15 → limit resets at 12:15 instead of 14:00
 
 ## Usage
 
@@ -27,7 +31,7 @@ npm install -g ccwarm
 ## Usage
 
 ```bash
-ccwarm analyze [days]  # Analyze usage patterns (default: 21 days)
+ccwarm analyze [days]  # Analyze usage patterns (default: 30 days)
 ccwarm warmup          # Run warmup check now
 ccwarm start           # Start background daemon
 ccwarm stop            # Stop daemon

package/dist/index.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import { spawn } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import { consola } from 'consola';
 import { createWarmupPlan } from './src/analyzer.js';
 import { paths } from './src/config.js';
-import { getDaemonStatus, startDaemon, stopDaemon } from './src/daemon/manager.js';
+import { getDaemonLogs, getDaemonStatus, startDaemon, stopDaemon } from './src/daemon/manager.js';
+import { formatDuration, formatTime } from './src/utils.js';
 import { runWarmupWorker } from './src/worker.js';
 const cmd = process.argv[2] ?? '';
 const commands = {
     async analyze() {
-        const days = parseInt(process.argv[3] ?? '21', 10);
+        const days = parseInt(process.argv[3] ?? '30', 10);
         await createWarmupPlan(days);
     },
     async warmup() {
@@ -41,9 +41,9 @@ const commands = {
                 plan
                     ? [
                         'Warmup Plan:',
-                        `  Target Hour: ${plan.targetHour}:00`,
-                        `  Median Start: ${plan.medianStartHour}:00`,
-                        `  Median Duration: ${plan.medianDurationHours.toFixed(2)}h`,
+                        `  Target Time: ${formatTime(plan.targetMinute)}`,
+                        `  Median Start: ${formatTime(plan.medianStartMinute)}`,
+                        `  Median Duration: ${formatDuration(plan.medianDurationMinutes)}`,
                         `  Calculated: ${plan.calculatedAt}`,
                     ].join('\n')
                     : "No warmup plan. Run 'ccwarm analyze' first.",
@@ -51,8 +51,7 @@ const commands = {
         });
     },
     async logs() {
-        const tail = spawn('tail', ['-f', paths.log], { stdio: 'inherit' });
-        tail.on('error', () => consola.error(`Cannot read: ${paths.log}`));
+        await getDaemonLogs();
     },
 };
 const run = commands[cmd];
@@ -66,7 +65,7 @@ else {
             'Usage: ccwarm <command>',
             '',
             'Commands:',
-            '  analyze [days]  Analyze usage patterns (default: 21 days)',
+            '  analyze [days]  Analyze usage patterns (default: 30 days)',
             '  warmup          Run warmup check now',
             '  start           Start background daemon',
             '  stop            Stop background daemon',

package/dist/src/analyzer.js

@@ -2,23 +2,8 @@ import { writeFile } from 'node:fs/promises';
 import { loadSessionBlockData } from 'ccusage/data-loader';
 import { consola } from 'consola';
 import { ensureConfigDir, paths } from './config.js';
-const median = (arr) => {
-    if (!arr.length)
-        return 0;
-    const sorted = arr.toSorted((a, b) => a - b);
-    const mid = Math.floor(sorted.length / 2);
-    if (sorted.length % 2) {
-        return sorted[mid] ?? 0;
-    }
-    return ((sorted[mid - 1] ?? 0) + (sorted[mid] ?? 0)) / 2;
-};
-const daysAgo = (n) => {
-    const d = new Date();
-    d.setDate(d.getDate() - n);
-    const [date] = d.toISOString().split('T');
-    return date?.replace(/-/g, '') ?? '';
-};
-export async function createWarmupPlan(days = 21) {
+import { daysAgo, formatTime, median } from './utils.js';
+export async function createWarmupPlan(days = 30) {
     consola.info(`Analyzing Claude usage patterns (last ${days} days)...`);
     try {
         await ensureConfigDir();
@@ -31,33 +16,36 @@ export async function createWarmupPlan(days = 21) {
         const MIN_SESSION_MINUTES = 1;
         const sessions = blocks
             .filter((b) => !b.isGap && !!b.actualEndTime)
-            .map((b) => ({
-            startHour: new Date(b.startTime).getHours(),
-            durationMs: new Date(b.actualEndTime).getTime() - new Date(b.startTime).getTime(),
-        }))
+            .map((b) => {
+            const start = new Date(b.startTime);
+            return {
+                startMinute: start.getHours() * 60 + start.getMinutes(),
+                durationMs: new Date(b.actualEndTime).getTime() - start.getTime(),
+            };
+        })
             .filter((s) => s.durationMs >= MIN_SESSION_MINUTES * 60_000)
             .map((s) => ({
-            startHour: s.startHour,
-            duration: s.durationMs / 3600000,
+            startMinute: s.startMinute,
+            durationMinutes: s.durationMs / 60_000,
         }));
         const MIN_SESSIONS = 3;
         if (sessions.length < MIN_SESSIONS) {
             consola.warn(`Not enough data (need at least ${MIN_SESSIONS} sessions)`);
             return null;
         }
-        const medianStart = median(sessions.map((s) => s.startHour));
-        const medianDuration = median(sessions.map((s) => s.duration));
-        let targetHour = Math.floor(medianStart - medianDuration / 2);
-        if (targetHour < 0)
-            targetHour += 24;
+        const medianStartMinute = median(sessions.map((s) => s.startMinute));
+        const medianDurationMinutes = median(sessions.map((s) => s.durationMinutes));
+        let targetMinute = Math.round(medianStartMinute - medianDurationMinutes / 2);
+        if (targetMinute < 0)
+            targetMinute += 24 * 60;
         const plan = {
-            targetHour,
-            medianStartHour: medianStart,
-            medianDurationHours: medianDuration,
+            targetMinute,
+            medianStartMinute,
+            medianDurationMinutes,
             calculatedAt: new Date().toISOString(),
         };
         await writeFile(paths.plan, JSON.stringify(plan, null, 2));
-        consola.success(`Plan updated: Target Warmup at ${targetHour}:00`);
+        consola.success(`Plan updated: Target Warmup at ${formatTime(targetMinute)}`);
         return plan;
     }
     catch (error) {

package/dist/src/daemon/manager.js

@@ -2,6 +2,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { consola } from 'consola';
+import { getNextWarmupDate, loadPlan } from '../utils.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const APP_NAME = 'ccwarm';
 const pm2 = (args) => new Promise((resolve) => {
@@ -46,6 +47,15 @@ export async function startDaemon() {
     if (code === 0) {
         const newStatus = await getDaemonStatus();
         consola.success(`Daemon started (PID: ${newStatus.pid})`);
+        let plan = await loadPlan();
+        if (!plan) {
+            consola.info('No warmup plan found, running analyze...');
+            const { createWarmupPlan } = await import('../analyzer.js');
+            plan = await createWarmupPlan();
+        }
+        if (plan) {
+            consola.info(`Next warmup: ${getNextWarmupDate(plan.targetMinute).toLocaleString()}`);
+        }
         return true;
     }
     consola.error('Failed to start daemon');

package/dist/src/types.d.ts

@@ -1,6 +1,9 @@
 export interface WarmupPlan {
-    targetHour: number;
-    medianStartHour: number;
-    medianDurationHours: number;
+    /** Target warmup time in minutes from midnight (0-1439) */
+    targetMinute: number;
+    /** Median session start time in minutes from midnight */
+    medianStartMinute: number;
+    /** Median session duration in minutes */
+    medianDurationMinutes: number;
     calculatedAt: string;
 }

package/dist/src/utils.d.ts

@@ -0,0 +1,11 @@
+import type { WarmupPlan } from './types.js';
+export declare const median: (arr: number[]) => number;
+export declare const daysAgo: (n: number) => string;
+export declare const loadPlan: () => Promise<WarmupPlan | null>;
+export declare const getNextWarmupDate: (targetMinute: number) => Date;
+/** Parse time string like "11:30" or "11" to minutes from midnight */
+export declare const parseTime: (input: string) => number | null;
+/** Format minutes from midnight to HH:MM string */
+export declare const formatTime: (minutes: number) => string;
+/** Format duration in minutes to human readable string */
+export declare const formatDuration: (minutes: number) => string;

package/dist/src/utils.js

@@ -0,0 +1,67 @@
+import { readFile } from 'node:fs/promises';
+import { paths } from './config.js';
+export const median = (arr) => {
+    if (!arr.length)
+        return 0;
+    const sorted = arr.toSorted((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? (sorted[mid] ?? 0) : ((sorted[mid - 1] ?? 0) + (sorted[mid] ?? 0)) / 2;
+};
+export const daysAgo = (n) => {
+    const d = new Date();
+    d.setDate(d.getDate() - n);
+    return d.toISOString().split('T')[0]?.replace(/-/g, '') ?? '';
+};
+export const loadPlan = async () => {
+    try {
+        return JSON.parse(await readFile(paths.plan, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+};
+export const getNextWarmupDate = (targetMinute) => {
+    const date = new Date();
+    const hours = Math.floor(targetMinute / 60);
+    const minutes = targetMinute % 60;
+    date.setHours(hours, minutes, 0, 0);
+    if (date <= new Date())
+        date.setDate(date.getDate() + 1);
+    return date;
+};
+/** Parse time string like "11:30" or "11" to minutes from midnight */
+export const parseTime = (input) => {
+    const trimmed = input.trim();
+    // Format: HH:MM or H:MM
+    if (trimmed.includes(':')) {
+        const [hourStr, minStr] = trimmed.split(':');
+        const hour = parseInt(hourStr ?? '', 10);
+        const min = parseInt(minStr ?? '', 10);
+        if (Number.isNaN(hour) || Number.isNaN(min) || hour < 0 || hour > 23 || min < 0 || min > 59) {
+            return null;
+        }
+        return hour * 60 + min;
+    }
+    // Format: HH or H (just hours)
+    const hour = parseInt(trimmed, 10);
+    if (Number.isNaN(hour) || hour < 0 || hour > 23) {
+        return null;
+    }
+    return hour * 60;
+};
+/** Format minutes from midnight to HH:MM string */
+export const formatTime = (minutes) => {
+    const h = Math.floor(minutes / 60);
+    const m = minutes % 60;
+    return `${h.toString().padStart(2, '0')}:${m.toString().padStart(2, '0')}`;
+};
+/** Format duration in minutes to human readable string */
+export const formatDuration = (minutes) => {
+    const h = Math.floor(minutes / 60);
+    const m = Math.round(minutes % 60);
+    if (h === 0)
+        return `${m}m`;
+    if (m === 0)
+        return `${h}h`;
+    return `${h}h ${m}m`;
+};

package/dist/src/worker.js

@@ -1,17 +1,22 @@
-import { readFile } from 'node:fs/promises';
 import { loadSessionBlockData } from 'ccusage/data-loader';
 import { consola } from 'consola';
 import { execa } from 'execa';
-import { paths } from './config.js';
+import { formatTime, loadPlan } from './utils.js';
 export async function runWarmupWorker() {
     try {
-        const plan = JSON.parse(await readFile(paths.plan, 'utf-8'));
-        const currentHour = new Date().getHours();
-        if (currentHour !== plan.targetHour) {
-            consola.debug(`Not warmup time. Current: ${currentHour}:00, Target: ${plan.targetHour}:00`);
+        const plan = await loadPlan();
+        if (!plan) {
+            consola.warn("No warmup plan found. Run 'ccwarm analyze' first.");
+            return false;
+        }
+        const now = new Date();
+        const currentMinute = now.getHours() * 60 + now.getMinutes();
+        const effectiveMinute = plan.targetMinute;
+        if (currentMinute !== effectiveMinute) {
+            consola.debug(`Not warmup time. Current: ${formatTime(currentMinute)}, Target: ${formatTime(effectiveMinute)}`);
             return false;
         }
-        consola.info('Target hour matched. Checking for active sessions...');
+        consola.info('Target time matched. Checking for active sessions...');
         const blocks = await loadSessionBlockData();
         if (blocks?.some((b) => b.isActive)) {
             consola.info('Session already active. Skipping warmup.');
@@ -23,12 +28,7 @@ export async function runWarmupWorker() {
         return true;
     }
     catch (err) {
-        if (err.code === 'ENOENT') {
-            consola.warn("No warmup plan found. Run 'ccwarm analyze' first.");
-        }
-        else {
-            consola.error('Warmup failed:', err);
-        }
+        consola.error('Warmup failed:', err);
         return false;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccwarm-temp",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Claude Auto-Warmer - Automatically warm up Claude based on your usage patterns",
   "type": "module",
   "bin": {