ccwarm-temp 1.0.0

package/README.md

@@ -0,0 +1,37 @@
+# ccwarm
+
+Optimize your Claude Code rate limit window by pre-warming sessions based on your usage patterns.
+
+## 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.
+
+## 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.
+
+**Example:** You work 9:00-13:30 → ccwarm sends "hi" at 7:15 → limit resets at 12:15 instead of 14:00
+
+## Usage
+
+```bash
+npx ccwarm
+```
+
+Or install globally:
+
+```bash
+npm install -g ccwarm
+```
+
+## Usage
+
+```bash
+ccwarm analyze [days]  # Analyze usage patterns (default: 21 days)
+ccwarm warmup          # Run warmup check now
+ccwarm start           # Start background daemon
+ccwarm stop            # Stop daemon
+ccwarm restart         # Restart daemon
+ccwarm status          # Show status and plan
+ccwarm logs            # Follow daemon logs
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,78 @@
+#!/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 { runWarmupWorker } from './src/worker.js';
+const cmd = process.argv[2] ?? '';
+const commands = {
+    async analyze() {
+        const days = parseInt(process.argv[3] ?? '21', 10);
+        await createWarmupPlan(days);
+    },
+    async warmup() {
+        await runWarmupWorker();
+    },
+    async start() {
+        await startDaemon();
+    },
+    async stop() {
+        await stopDaemon();
+    },
+    async restart() {
+        await stopDaemon();
+        await new Promise((r) => setTimeout(r, 500));
+        await startDaemon();
+    },
+    async status() {
+        const daemon = await getDaemonStatus();
+        let plan = null;
+        try {
+            plan = JSON.parse(await readFile(paths.plan, 'utf-8'));
+        }
+        catch { }
+        consola.box({
+            title: 'ccwarm Status',
+            message: [
+                `Daemon: ${daemon.running ? `Running (PID: ${daemon.pid})` : 'Stopped'}`,
+                '',
+                plan
+                    ? [
+                        'Warmup Plan:',
+                        `  Target Hour: ${plan.targetHour}:00`,
+                        `  Median Start: ${plan.medianStartHour}:00`,
+                        `  Median Duration: ${plan.medianDurationHours.toFixed(2)}h`,
+                        `  Calculated: ${plan.calculatedAt}`,
+                    ].join('\n')
+                    : "No warmup plan. Run 'ccwarm analyze' first.",
+            ].join('\n'),
+        });
+    },
+    async logs() {
+        const tail = spawn('tail', ['-f', paths.log], { stdio: 'inherit' });
+        tail.on('error', () => consola.error(`Cannot read: ${paths.log}`));
+    },
+};
+const run = commands[cmd];
+if (run) {
+    await run();
+}
+else {
+    consola.box({
+        title: 'ccwarm - Claude Auto-Warmer',
+        message: [
+            'Usage: ccwarm <command>',
+            '',
+            'Commands:',
+            '  analyze [days]  Analyze usage patterns (default: 21 days)',
+            '  warmup          Run warmup check now',
+            '  start           Start background daemon',
+            '  stop            Stop background daemon',
+            '  restart         Restart background daemon',
+            '  status          Show daemon and plan status',
+            '  logs            Follow daemon log output',
+        ].join('\n'),
+    });
+}

package/dist/src/analyzer.d.ts

@@ -0,0 +1,2 @@
+import type { WarmupPlan } from './types.js';
+export declare function createWarmupPlan(days?: number): Promise<WarmupPlan | null>;

package/dist/src/analyzer.js

@@ -0,0 +1,67 @@
+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) {
+    consola.info(`Analyzing Claude usage patterns (last ${days} days)...`);
+    try {
+        await ensureConfigDir();
+        const blocks = await loadSessionBlockData({ since: daysAgo(days), offline: true });
+        if (!blocks?.length) {
+            consola.warn('No usage blocks found');
+            return null;
+        }
+        // Filter out very short sessions (e.g., warmup pings) to avoid skewing analysis
+        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(),
+        }))
+            .filter((s) => s.durationMs >= MIN_SESSION_MINUTES * 60_000)
+            .map((s) => ({
+            startHour: s.startHour,
+            duration: s.durationMs / 3600000,
+        }));
+        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 plan = {
+            targetHour,
+            medianStartHour: medianStart,
+            medianDurationHours: medianDuration,
+            calculatedAt: new Date().toISOString(),
+        };
+        await writeFile(paths.plan, JSON.stringify(plan, null, 2));
+        consola.success(`Plan updated: Target Warmup at ${targetHour}:00`);
+        return plan;
+    }
+    catch (error) {
+        consola.error('Analysis failed:', error);
+        return null;
+    }
+}

package/dist/src/config.d.ts

@@ -0,0 +1,11 @@
+export declare const paths: {
+    readonly config: string;
+    readonly plan: string;
+    readonly pid: string;
+    readonly log: string;
+};
+export declare const timing: {
+    readonly hour: number;
+    readonly day: number;
+};
+export declare const ensureConfigDir: () => Promise<string | undefined>;

package/dist/src/config.js

@@ -0,0 +1,15 @@
+import { mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const home = homedir();
+export const paths = {
+    config: join(home, '.ccwarm'),
+    plan: join(home, '.ccwarm', 'warmup_plan.json'),
+    pid: join(home, '.ccwarm', 'daemon.pid'),
+    log: join(home, '.ccwarm', 'daemon.log'),
+};
+export const timing = {
+    hour: 60 * 60 * 1000,
+    day: 24 * 60 * 60 * 1000,
+};
+export const ensureConfigDir = () => mkdir(paths.config, { recursive: true });

package/dist/src/daemon/manager.d.ts

@@ -0,0 +1,8 @@
+export interface DaemonStatus {
+    running: boolean;
+    pid?: number;
+}
+export declare function getDaemonStatus(): Promise<DaemonStatus>;
+export declare function startDaemon(): Promise<boolean>;
+export declare function stopDaemon(): Promise<boolean>;
+export declare function getDaemonLogs(): Promise<void>;

package/dist/src/daemon/manager.js

@@ -0,0 +1,70 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { consola } from 'consola';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const APP_NAME = 'ccwarm';
+const pm2 = (args) => new Promise((resolve) => {
+    const p = spawn('npx', ['pm2', ...args], { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    p.stdout?.on('data', (d) => {
+        stdout += d;
+    });
+    p.stderr?.on('data', (d) => {
+        stdout += d;
+    });
+    p.on('close', (code) => resolve({ code: code ?? 1, stdout }));
+});
+export async function getDaemonStatus() {
+    const { stdout } = await pm2(['jlist']);
+    try {
+        const list = JSON.parse(stdout);
+        const app = list.find((p) => p.name === APP_NAME);
+        if (app && app.pm2_env?.status === 'online') {
+            return { running: true, pid: app.pid };
+        }
+    }
+    catch { }
+    return { running: false };
+}
+export async function startDaemon() {
+    const status = await getDaemonStatus();
+    if (status.running) {
+        consola.warn(`Daemon already running (PID: ${status.pid})`);
+        return false;
+    }
+    const runnerPath = join(__dirname, 'runner.js');
+    const { code } = await pm2([
+        'start',
+        runnerPath,
+        '--name',
+        APP_NAME,
+        '--interpreter',
+        'node',
+        '--no-autorestart',
+    ]);
+    if (code === 0) {
+        const newStatus = await getDaemonStatus();
+        consola.success(`Daemon started (PID: ${newStatus.pid})`);
+        return true;
+    }
+    consola.error('Failed to start daemon');
+    return false;
+}
+export async function stopDaemon() {
+    const status = await getDaemonStatus();
+    if (!status.running) {
+        consola.warn('Daemon is not running');
+        return false;
+    }
+    const { code } = await pm2(['delete', APP_NAME]);
+    if (code === 0) {
+        consola.success(`Daemon stopped (PID: ${status.pid})`);
+        return true;
+    }
+    consola.error('Failed to stop daemon');
+    return false;
+}
+export async function getDaemonLogs() {
+    spawnSync('npx', ['pm2', 'logs', APP_NAME, '--lines', '50'], { stdio: 'inherit' });
+}

package/dist/src/daemon/runner.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/daemon/runner.js

@@ -0,0 +1,18 @@
+import { createWarmupPlan } from '../analyzer.js';
+import { timing } from '../config.js';
+import { runWarmupWorker } from '../worker.js';
+const log = (msg) => console.log(`[${new Date().toISOString()}] ${msg}`);
+log(`Daemon started (PID: ${process.pid})`);
+// Initial run
+await createWarmupPlan();
+await runWarmupWorker();
+// Schedule recurring tasks
+setInterval(async () => {
+    log('Running daily analysis...');
+    await createWarmupPlan();
+}, timing.day);
+setInterval(async () => {
+    log('Running hourly warmup check...');
+    await runWarmupWorker();
+}, timing.hour);
+log('Daemon running. Analysis: every 24h, Warmup check: every 1h');

package/dist/src/types.d.ts

@@ -0,0 +1,6 @@
+export interface WarmupPlan {
+    targetHour: number;
+    medianStartHour: number;
+    medianDurationHours: number;
+    calculatedAt: string;
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/worker.d.ts

@@ -0,0 +1 @@
+export declare function runWarmupWorker(): Promise<boolean>;

package/dist/src/worker.js

@@ -0,0 +1,34 @@
+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';
+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`);
+            return false;
+        }
+        consola.info('Target hour matched. Checking for active sessions...');
+        const blocks = await loadSessionBlockData();
+        if (blocks?.some((b) => b.isActive)) {
+            consola.info('Session already active. Skipping warmup.');
+            return false;
+        }
+        consola.start('Warming up Claude...');
+        await execa('claude', ['-c', 'say hi'], { stdio: 'inherit', timeout: 60_000 });
+        consola.success('Warmup complete!');
+        return true;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            consola.warn("No warmup plan found. Run 'ccwarm analyze' first.");
+        }
+        else {
+            consola.error('Warmup failed:', err);
+        }
+        return false;
+    }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "ccwarm-temp",
+  "version": "1.0.0",
+  "description": "Claude Auto-Warmer - Automatically warm up Claude based on your usage patterns",
+  "type": "module",
+  "bin": {
+    "ccwarm": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "format": "biome format --write .",
+    "format:check": "biome check .",
+    "lint": "biome lint .",
+    "lint:fix": "biome lint --write ."
+  },
+  "keywords": [
+    "claude",
+    "anthropic",
+    "warmup",
+    "cli"
+  ],
+  "author": "",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.11",
+    "@types/node": "^25.0.3",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "ccusage": "^17.2.1",
+    "consola": "^3.4.2",
+    "execa": "^9.6.1",
+    "pm2": "^6.0.14"
+  }
+}