bugcap 0.1.0

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { render } from "ink";
+import React from "react";
+import { resetState, loadState } from "./state.js";
+import { startWatcher, startEmbeddedWatcher } from "./watcher.js";
+import Game from "./components/Game.js";
+const program = new Command();
+program
+    .name("bugcap")
+    .description("Turn your AI coding into a terminal idle game")
+    .version("0.1.0");
+// Default command — watcher + TUI together
+program
+    .action(() => {
+    const dir = process.cwd();
+    const cleanupWatcher = startEmbeddedWatcher(dir);
+    const { unmount } = render(React.createElement(Game));
+    function cleanup() {
+        cleanupWatcher();
+        unmount();
+        process.exit(0);
+    }
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+});
+// Watch command — headless watcher (no TUI)
+program
+    .command("watch [path]")
+    .description("Start a headless watcher (no game UI) for an additional project directory")
+    .action((targetPath) => {
+    const dir = targetPath ?? process.cwd();
+    startWatcher(dir);
+});
+// Reset command
+program
+    .command("reset")
+    .description("Reset all game progress")
+    .option("-f, --force", "Skip confirmation prompt")
+    .action(async (options) => {
+    const state = loadState();
+    if (!state) {
+        console.log("No game data to reset.");
+        return;
+    }
+    if (!options.force) {
+        const readline = await import("node:readline");
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const answer = await new Promise((resolve) => {
+            rl.question(`Are you sure you want to reset? You'll lose $${state.money.toLocaleString()} and ${state.tokens.toLocaleString()} tokens. (y/N) `, resolve);
+        });
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+            console.log("Reset cancelled.");
+            return;
+        }
+    }
+    resetState();
+    console.log("Game progress has been reset.");
+});
+program.parse();

package/dist/components/Game.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export default function Game(): React.JSX.Element;

package/dist/components/Game.js

@@ -0,0 +1,172 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Box, Text, useStdout } from "ink";
+import { loadState, loadRecentEvents, } from "../state.js";
+import { getLevelMultiplier } from "../economy.js";
+// ── Helpers ──────────────────────────────────────────────
+function formatNumber(n) {
+    return n.toLocaleString("en-US");
+}
+function formatMoney(n) {
+    if (n >= 1_000_000)
+        return `$${(n / 1_000_000).toFixed(2)}M`;
+    if (n >= 10_000)
+        return `$${(n / 1_000).toFixed(1)}K`;
+    return `$${formatNumber(n)}`;
+}
+function xpForNextLevel(level) {
+    return (level + 1) * 500;
+}
+function timeAgo(timestamp) {
+    const seconds = Math.floor((Date.now() - timestamp) / 1000);
+    if (seconds < 5)
+        return "now";
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h`;
+}
+// ── ASCII Art ────────────────────────────────────────────
+const LOGO_LINES = [
+    " ____  _   _  ____     ____    _    ____  ",
+    "| __ )| | | |/ ___|   / ___|  / \\  |  _ \\ ",
+    "|  _ \\| | | | |  _   | |     / _ \\ | |_) |",
+    "| |_) | |_| | |_| |  | |___ / ___ \\|  __/ ",
+    "|____/ \\___/ \\____|   \\____/_/   \\_\\_|    ",
+];
+const LOGO_COLORS = [
+    "green",
+    "green",
+    "cyan",
+    "cyan",
+    "yellow",
+];
+const BUG_ART = [
+    "     _         ",
+    "    / \\        ",
+    "   / _ \\       ",
+    "  | |_| |      ",
+    "   \\___/  BUG! ",
+];
+const MINI_BUG = "~(o.o)~";
+// ── Animated Components ──────────────────────────────────
+const PULSE_FRAMES = ["*", "o", "O", "o"];
+const SPINNER_FRAMES = ["   ", ".  ", ".. ", "..."];
+function useAnimationFrame(fps = 4) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const interval = setInterval(() => {
+            setFrame((f) => f + 1);
+        }, 1000 / fps);
+        return () => clearInterval(interval);
+    }, [fps]);
+    return frame;
+}
+// ── Progress Bar ─────────────────────────────────────────
+function ProgressBar({ current, max, width = 20, filledColor = "green", emptyColor, }) {
+    const ratio = Math.min(current / max, 1);
+    const filled = Math.round(ratio * width);
+    const empty = width - filled;
+    const percent = Math.round(ratio * 100);
+    return (_jsxs(Text, { children: [_jsx(Text, { color: "white", children: "[" }), _jsx(Text, { color: filledColor, children: "█".repeat(filled) }), _jsx(Text, { dimColor: true, children: "░".repeat(empty) }), _jsx(Text, { color: "white", children: "]" }), _jsxs(Text, { dimColor: true, children: [" ", percent, "%"] })] }));
+}
+// ── Stat Box ─────────────────────────────────────────────
+function StatBox({ label, value, color = "white", }) {
+    return (_jsxs(Box, { flexDirection: "column", marginRight: 2, children: [_jsx(Text, { dimColor: true, children: label }), _jsx(Text, { bold: true, color: color, children: value })] }));
+}
+// ── Event Line ───────────────────────────────────────────
+function EventLine({ event, showTime = false, }) {
+    const iconMap = {
+        token_gain: " +",
+        bug_found: " !",
+        bug_sold: " $",
+        level_up: " *",
+    };
+    const colorMap = {
+        token_gain: "green",
+        bug_found: "red",
+        bug_sold: "yellow",
+        level_up: "cyan",
+    };
+    const icon = iconMap[event.type] ?? " ?";
+    const color = colorMap[event.type] ?? "white";
+    return (_jsxs(Box, { children: [_jsx(Text, { color: color, bold: true, children: icon }), _jsx(Text, { children: " " }), _jsx(Text, { color: color, children: event.description ?? event.type }), showTime && _jsxs(Text, { dimColor: true, children: [" ", timeAgo(event.timestamp)] })] }));
+}
+// ── Welcome Screen ───────────────────────────────────────
+function WelcomeScreen() {
+    const frame = useAnimationFrame(2);
+    const bugFrame = frame % 2 === 0 ? MINI_BUG : "~(O.O)~";
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { flexDirection: "column", marginBottom: 1, children: LOGO_LINES.map((line, i) => (_jsx(Text, { color: LOGO_COLORS[i], children: line }, i))) }), _jsxs(Box, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: bugFrame }), _jsx(Text, { children: " Watching for changes... Start coding!" })] }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "Your AI coding activity will appear here." }), _jsx(Text, { dimColor: true, children: "Watch extra projects: npx bugcap watch ~/other-project" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, italic: true, children: "Turn your AI coding into a terminal idle game" }) })] }));
+}
+// ── Compact View ─────────────────────────────────────────
+function CompactView({ state, isOnline, }) {
+    const frame = useAnimationFrame(2);
+    const pulse = isOnline ? PULSE_FRAMES[frame % PULSE_FRAMES.length] : "x";
+    const pulseColor = isOnline ? "green" : "red";
+    return (_jsx(Box, { flexDirection: "column", padding: 1, children: _jsxs(Text, { children: [_jsxs(Text, { color: pulseColor, children: ["[", pulse, "]"] }), _jsxs(Text, { bold: true, color: "green", children: [" ", "BUG CAP", " "] }), _jsx(Text, { bold: true, color: "yellow", children: formatMoney(state.money) }), _jsx(Text, { dimColor: true, children: " | " }), _jsxs(Text, { color: "cyan", children: ["Lv", state.level] }), _jsx(Text, { dimColor: true, children: " | " }), _jsxs(Text, { children: ["T:", formatNumber(state.tokens)] }), _jsx(Text, { dimColor: true, children: " | " }), _jsxs(Text, { color: "red", children: ["B:", state.bugsSold] })] }) }));
+}
+// ── Normal View ──────────────────────────────────────────
+function NormalView({ state, events, isOnline, }) {
+    const frame = useAnimationFrame(4);
+    const multiplier = getLevelMultiplier(state.level);
+    const xpNeeded = xpForNextLevel(state.level);
+    const xpProgress = Math.min(state.xp, xpNeeded);
+    // Animated watcher indicator
+    const pulse = isOnline ? PULSE_FRAMES[frame % PULSE_FRAMES.length] : "x";
+    const pulseColor = isOnline ? "green" : "red";
+    const statusText = isOnline ? "LIVE" : "OFFLINE";
+    // Money flash effect: alternate bold on recent change
+    const recentMoney = events.some((e) => e.type === "bug_sold" && Date.now() - e.timestamp < 3000);
+    const moneyFlash = recentMoney && frame % 2 === 0;
+    // Activity dots
+    const dots = isOnline ? SPINNER_FRAMES[frame % SPINNER_FRAMES.length] : "";
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { flexDirection: "row", justifyContent: "space-between", children: _jsx(Box, { children: LOGO_LINES.map((line, i) => (_jsx(Text, { color: LOGO_COLORS[i], children: i === 0 ? line : "\n" + line }, i))) }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsxs(Text, { color: pulseColor, bold: true, children: ["[", pulse, "]"] }), _jsxs(Text, { color: pulseColor, bold: true, children: [" ", statusText] }), _jsx(Text, { dimColor: true, children: dots })] }) }), _jsx(Box, { borderStyle: "round", borderColor: moneyFlash ? "green" : "yellow", paddingX: 2, marginTop: 1, children: _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Bug Bounty" }), _jsxs(Text, { bold: true, color: moneyFlash ? "green" : "yellow", children: ["  ", "$", formatNumber(state.money)] })] }) }), _jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsx(StatBox, { label: "Level", value: `${state.level} (${multiplier.toFixed(2)}x)`, color: "cyan" }), _jsx(StatBox, { label: "Bugs Sold", value: formatNumber(state.bugsSold), color: "red" }), _jsx(StatBox, { label: "Tokens", value: formatNumber(state.tokens), color: "green" })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "XP " }), _jsxs(Text, { children: [formatNumber(xpProgress), "/", formatNumber(xpNeeded)] })] }), _jsx(ProgressBar, { current: xpProgress, max: xpNeeded, width: 30, filledColor: "cyan" })] }), events.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsxs(Text, { bold: true, dimColor: true, children: [" ", "Recent Activity", " "] }), events.map((event, i) => (_jsx(EventLine, { event: event, showTime: i === events.length - 1 }, i)))] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, italic: true, children: [MINI_BUG, " Keep coding to earn more!"] }) })] }));
+}
+// ── Main Component ───────────────────────────────────────
+export default function Game() {
+    const [state, setState] = useState(null);
+    const [events, setEvents] = useState([]);
+    const [initialized, setInitialized] = useState(false);
+    const { stdout } = useStdout();
+    const columns = stdout?.columns ?? 80;
+    useEffect(() => {
+        function poll() {
+            const s = loadState();
+            setState(s);
+            if (s) {
+                setEvents(loadRecentEvents(8));
+            }
+            if (!initialized)
+                setInitialized(true);
+        }
+        poll();
+        const interval = setInterval(poll, 1000);
+        return () => clearInterval(interval);
+    }, [initialized]);
+    if (!initialized) {
+        return (_jsx(Box, { padding: 1, children: _jsx(Text, { color: "cyan", children: "Loading..." }) }));
+    }
+    if (!state) {
+        return _jsx(WelcomeScreen, {});
+    }
+    const isOnline = isWatcherOnline(state);
+    if (columns < 60) {
+        return _jsx(CompactView, { state: state, isOnline: isOnline });
+    }
+    return _jsx(NormalView, { state: state, events: events, isOnline: isOnline });
+}
+function isWatcherOnline(state) {
+    if (state.watcherPid) {
+        try {
+            process.kill(state.watcherPid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}

package/dist/economy.d.ts

@@ -0,0 +1,3 @@
+import { GameState, GameEvent } from "./state.js";
+export declare function getLevelMultiplier(level: number): number;
+export declare function processFileChange(state: GameState, linesChanged: number): GameEvent[];

package/dist/economy.js

@@ -0,0 +1,77 @@
+import { appendEvent } from "./state.js";
+// Tokens earned per line changed
+const TOKENS_PER_LINE = 5;
+// Base bug chance per batch of changes (percentage)
+const BUG_BASE_CHANCE = 15;
+// Extra bug chance per 50 lines changed
+const BUG_CHANCE_PER_50_LINES = 10;
+// Base price for selling a bug
+const BUG_BASE_PRICE = 25;
+// XP gained per token earned
+const XP_PER_TOKEN = 0.1;
+// XP required for each level: level N requires N * 500 XP
+function xpForLevel(level) {
+    return level * 500;
+}
+export function getLevelMultiplier(level) {
+    return 1 + (level - 1) * 0.25;
+}
+export function processFileChange(state, linesChanged) {
+    const events = [];
+    // Calculate tokens
+    const tokens = Math.max(1, Math.round(linesChanged * TOKENS_PER_LINE));
+    state.tokens += tokens;
+    const tokenEvent = {
+        type: "token_gain",
+        value: tokens,
+        timestamp: Date.now(),
+        description: `${linesChanged} lines changed — +${tokens} tokens`,
+    };
+    events.push(tokenEvent);
+    appendEvent(tokenEvent);
+    // XP gain
+    state.xp += Math.round(tokens * XP_PER_TOKEN);
+    // Check level up
+    while (state.xp >= xpForLevel(state.level + 1)) {
+        state.level++;
+        const levelEvent = {
+            type: "level_up",
+            value: state.level,
+            timestamp: Date.now(),
+            description: `Level up! Now level ${state.level}`,
+        };
+        events.push(levelEvent);
+        appendEvent(levelEvent);
+    }
+    // Bug generation — chance increases with more lines changed
+    const bugChance = BUG_BASE_CHANCE + Math.floor(linesChanged / 50) * BUG_CHANCE_PER_50_LINES;
+    if (Math.random() * 100 < bugChance) {
+        state.bugs++;
+        const bugEvent = {
+            type: "bug_found",
+            value: 1,
+            timestamp: Date.now(),
+            description: "Bug detected — queued for sale",
+        };
+        events.push(bugEvent);
+        appendEvent(bugEvent);
+    }
+    // Auto-sell bugs
+    while (state.bugs > 0) {
+        const multiplier = getLevelMultiplier(state.level);
+        const price = Math.round(BUG_BASE_PRICE * multiplier);
+        state.bugs--;
+        state.bugsSold++;
+        state.money += price;
+        const sellEvent = {
+            type: "bug_sold",
+            value: price,
+            timestamp: Date.now(),
+            description: `Bug sold — +$${price}`,
+        };
+        events.push(sellEvent);
+        appendEvent(sellEvent);
+    }
+    state.lastEventAt = Date.now();
+    return events;
+}

package/dist/state.d.ts

@@ -0,0 +1,23 @@
+export interface GameState {
+    tokens: number;
+    bugs: number;
+    bugsSold: number;
+    money: number;
+    xp: number;
+    level: number;
+    lastEventAt: number;
+    watcherPid: number | null;
+}
+export interface GameEvent {
+    type: "token_gain" | "bug_found" | "bug_sold" | "level_up";
+    value: number;
+    timestamp: number;
+    description?: string;
+}
+export declare function defaultState(): GameState;
+export declare function loadState(): GameState | null;
+export declare function saveState(state: GameState): void;
+export declare function appendEvent(event: GameEvent): void;
+export declare function loadRecentEvents(count?: number): GameEvent[];
+export declare function resetState(): void;
+export declare function getStatePath(): string;

package/dist/state.js

@@ -0,0 +1,87 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+const BUGCAP_DIR = path.join(os.homedir(), ".bugcap");
+const STATE_FILE = path.join(BUGCAP_DIR, "state.json");
+const EVENTS_FILE = path.join(BUGCAP_DIR, "events.jsonl");
+const MAX_EVENTS_SIZE = 5 * 1024 * 1024; // 5MB
+export function defaultState() {
+    return {
+        tokens: 0,
+        bugs: 0,
+        bugsSold: 0,
+        money: 0,
+        xp: 0,
+        level: 1,
+        lastEventAt: 0,
+        watcherPid: null,
+    };
+}
+function ensureDir() {
+    if (!fs.existsSync(BUGCAP_DIR)) {
+        fs.mkdirSync(BUGCAP_DIR, { recursive: true });
+    }
+}
+export function loadState() {
+    try {
+        if (!fs.existsSync(STATE_FILE))
+            return null;
+        const data = fs.readFileSync(STATE_FILE, "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveState(state) {
+    ensureDir();
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+export function appendEvent(event) {
+    ensureDir();
+    // Rotate if too large
+    try {
+        if (fs.existsSync(EVENTS_FILE)) {
+            const stats = fs.statSync(EVENTS_FILE);
+            if (stats.size >= MAX_EVENTS_SIZE) {
+                // Keep last half of the file
+                const content = fs.readFileSync(EVENTS_FILE, "utf-8");
+                const lines = content.trim().split("\n");
+                const half = lines.slice(Math.floor(lines.length / 2));
+                fs.writeFileSync(EVENTS_FILE, half.join("\n") + "\n");
+            }
+        }
+    }
+    catch {
+        // ignore rotation errors
+    }
+    fs.appendFileSync(EVENTS_FILE, JSON.stringify(event) + "\n");
+}
+export function loadRecentEvents(count = 10) {
+    try {
+        if (!fs.existsSync(EVENTS_FILE))
+            return [];
+        const content = fs.readFileSync(EVENTS_FILE, "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        return lines
+            .slice(-count)
+            .map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+export function resetState() {
+    try {
+        if (fs.existsSync(STATE_FILE))
+            fs.unlinkSync(STATE_FILE);
+        if (fs.existsSync(EVENTS_FILE))
+            fs.unlinkSync(EVENTS_FILE);
+    }
+    catch {
+        // ignore
+    }
+}
+export function getStatePath() {
+    return STATE_FILE;
+}

package/dist/watcher.d.ts

@@ -0,0 +1,4 @@
+/** Headless watcher with console output — used by `bugcap watch` */
+export declare function startWatcher(targetDir: string): void;
+/** Embedded watcher (no console output) — used by default `bugcap` command */
+export declare function startEmbeddedWatcher(targetDir: string): () => void;

package/dist/watcher.js

@@ -0,0 +1,170 @@
+import fs from "node:fs";
+import path from "node:path";
+import { watch } from "chokidar";
+import { loadState, saveState, defaultState } from "./state.js";
+import { processFileChange } from "./economy.js";
+const IGNORED_DIRS = [
+    ".git",
+    "node_modules",
+    "vendor",
+    "dist",
+    "build",
+    ".next",
+    "__pycache__",
+    ".venv",
+    "target",
+];
+// Track file sizes to estimate lines changed
+const fileSizes = new Map();
+function getFileLineCount(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return content.split("\n").length;
+    }
+    catch {
+        return 0;
+    }
+}
+function loadGitignorePatterns(dir) {
+    const gitignorePath = path.join(dir, ".gitignore");
+    try {
+        if (!fs.existsSync(gitignorePath))
+            return [];
+        const content = fs.readFileSync(gitignorePath, "utf-8");
+        return content
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith("#"));
+    }
+    catch {
+        return [];
+    }
+}
+// Debounce changes per file
+const pendingChanges = new Map();
+const DEBOUNCE_MS = 500;
+function createWatcher(targetDir) {
+    const resolvedDir = path.resolve(targetDir);
+    if (!fs.existsSync(resolvedDir)) {
+        throw new Error(`Directory "${resolvedDir}" does not exist.`);
+    }
+    // Load or create state
+    let state = loadState() ?? defaultState();
+    state.watcherPid = process.pid;
+    saveState(state);
+    // Build ignore patterns
+    const gitignorePatterns = loadGitignorePatterns(resolvedDir);
+    const ignored = [
+        ...IGNORED_DIRS.map((d) => `**/${d}/**`),
+        ...gitignorePatterns,
+    ];
+    const watcher = watch(resolvedDir, {
+        ignored,
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 300,
+            pollInterval: 100,
+        },
+    });
+    function handleChange(filePath) {
+        const existing = pendingChanges.get(filePath);
+        if (existing)
+            clearTimeout(existing);
+        pendingChanges.set(filePath, setTimeout(() => {
+            pendingChanges.delete(filePath);
+            const currentLines = getFileLineCount(filePath);
+            const previousLines = fileSizes.get(filePath) ?? 0;
+            const linesChanged = Math.abs(currentLines - previousLines);
+            fileSizes.set(filePath, currentLines);
+            if (linesChanged === 0 && previousLines > 0)
+                return;
+            const effectiveLines = Math.max(1, linesChanged);
+            state = loadState() ?? state;
+            processFileChange(state, effectiveLines);
+            saveState(state);
+        }, DEBOUNCE_MS));
+    }
+    return { watcher, handleChange };
+}
+/** Headless watcher with console output — used by `bugcap watch` */
+export function startWatcher(targetDir) {
+    const resolvedDir = path.resolve(targetDir);
+    let state;
+    const { watcher, handleChange } = createWatcher(resolvedDir);
+    state = loadState();
+    let totalTokens = state?.tokens ?? 0;
+    let totalBugs = state?.bugsSold ?? 0;
+    let eventCount = 0;
+    console.log(`Bug Capitalist — watching ${resolvedDir}`);
+    console.log("Capturing file changes... (Ctrl+C to stop)\n");
+    console.log("Open another terminal and run: npx bugcap");
+    console.log("to see your score and game progress.\n");
+    function updateStatusLine() {
+        const s = loadState();
+        if (s) {
+            totalTokens = s.tokens;
+            totalBugs = s.bugsSold;
+        }
+        process.stdout.write(`\rTokens: ${totalTokens.toLocaleString()} | Bugs sold: ${totalBugs} | Events: ${eventCount}   `);
+    }
+    updateStatusLine();
+    // Wrap handleChange to also update the status line
+    function handleChangeWithStatus(filePath) {
+        handleChange(filePath);
+        // Update status after debounce settles
+        setTimeout(() => {
+            eventCount++;
+            updateStatusLine();
+        }, DEBOUNCE_MS + 100);
+    }
+    watcher.on("add", handleChangeWithStatus);
+    watcher.on("change", handleChangeWithStatus);
+    watcher.on("unlink", (filePath) => {
+        const previousLines = fileSizes.get(filePath) ?? 0;
+        fileSizes.delete(filePath);
+        if (previousLines > 0) {
+            const s = loadState() ?? defaultState();
+            processFileChange(s, previousLines);
+            saveState(s);
+            eventCount++;
+            updateStatusLine();
+        }
+    });
+    function cleanup() {
+        console.log("\n\nWatcher stopped. Your progress has been saved.");
+        const s = loadState();
+        if (s) {
+            s.watcherPid = null;
+            saveState(s);
+        }
+        watcher.close();
+        process.exit(0);
+    }
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+}
+/** Embedded watcher (no console output) — used by default `bugcap` command */
+export function startEmbeddedWatcher(targetDir) {
+    const { watcher, handleChange } = createWatcher(targetDir);
+    watcher.on("add", handleChange);
+    watcher.on("change", handleChange);
+    watcher.on("unlink", (filePath) => {
+        const previousLines = fileSizes.get(filePath) ?? 0;
+        fileSizes.delete(filePath);
+        if (previousLines > 0) {
+            let state = loadState() ?? defaultState();
+            processFileChange(state, previousLines);
+            saveState(state);
+        }
+    });
+    // Return cleanup function
+    return () => {
+        const s = loadState();
+        if (s) {
+            s.watcherPid = null;
+            saveState(s);
+        }
+        watcher.close();
+    };
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "bugcap",
+  "version": "0.1.0",
+  "description": "Turn your AI coding into a terminal idle game",
+  "type": "module",
+  "bin": {
+    "bugcap": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/cli.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["cli", "terminal", "idle-game", "ai", "developer-tools"],
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.3",
+    "commander": "^13.1.0",
+    "ink": "^5.1.0",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "@types/react": "^18.3.18",
+    "typescript": "^5.8.2"
+  }
+}