burnrate 0.1.0

package/dist/cli/setup.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * BURNRATE Setup CLI
+ * Configures Claude Code MCP settings for BURNRATE
+ *
+ * Usage: npx burnrate setup
+ */
+export {};

package/dist/cli/setup.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * BURNRATE Setup CLI
+ * Configures Claude Code MCP settings for BURNRATE
+ *
+ * Usage: npx burnrate setup
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import readline from 'readline';
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+function ask(question, defaultValue) {
+    const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            resolve(answer.trim() || defaultValue || '');
+        });
+    });
+}
+async function main() {
+    console.log(`
+╔══════════════════════════════════════════════════════════════╗
+║                    BURNRATE SETUP                            ║
+║              The front doesn't feed itself.                  ║
+╚══════════════════════════════════════════════════════════════╝
+`);
+    // 1. Get API URL
+    const apiUrl = await ask('API server URL', 'https://api.burnrate.cc');
+    // 2. Get API key (optional — can join later)
+    const apiKey = await ask('API key (press Enter to skip — you can join in-game later)', '');
+    // 3. Validate connection
+    console.log(`\nTesting connection to ${apiUrl}...`);
+    try {
+        const response = await fetch(`${apiUrl}/health`);
+        const data = await response.json();
+        if (data.status === 'ok') {
+            console.log(`  ✓ Server is online (tick ${data.tick})`);
+        }
+        else {
+            console.log(`  ⚠ Server responded but may have issues: ${JSON.stringify(data)}`);
+        }
+    }
+    catch (error) {
+        console.log(`  ✗ Could not reach ${apiUrl}`);
+        console.log(`    Make sure the server is running and the URL is correct.`);
+        const proceed = await ask('Continue anyway? (y/n)', 'n');
+        if (proceed.toLowerCase() !== 'y') {
+            rl.close();
+            process.exit(1);
+        }
+    }
+    // 4. If we have an API key, validate it
+    if (apiKey) {
+        console.log('\nValidating API key...');
+        try {
+            const response = await fetch(`${apiUrl}/me`, {
+                headers: { 'X-API-Key': apiKey }
+            });
+            if (response.ok) {
+                const data = await response.json();
+                console.log(`  ✓ Authenticated as ${data.name} (${data.tier} tier, ${data.reputation} rep)`);
+            }
+            else {
+                console.log('  ✗ Invalid API key. You can set it later in your MCP config.');
+            }
+        }
+        catch {
+            console.log('  ⚠ Could not validate key (server unreachable).');
+        }
+    }
+    // 5. Find MCP server path
+    // When installed via npm, the MCP server is in the package's dist/ folder
+    // When running from source, it's relative to this file
+    let mcpServerPath;
+    // Check if we're running from an npm install (dist/cli/setup.js)
+    const distPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', 'mcp', 'server.js');
+    if (fs.existsSync(distPath)) {
+        mcpServerPath = distPath;
+    }
+    else {
+        // Fallback: ask the user
+        mcpServerPath = await ask('Path to MCP server (dist/mcp/server.js)', path.join(process.cwd(), 'dist', 'mcp', 'server.js'));
+    }
+    console.log(`\nMCP server path: ${mcpServerPath}`);
+    // 6. Write Claude Code settings
+    const claudeSettingsDir = path.join(os.homedir(), '.claude');
+    const claudeSettingsPath = path.join(claudeSettingsDir, 'settings.json');
+    let settings = {};
+    if (fs.existsSync(claudeSettingsPath)) {
+        try {
+            settings = JSON.parse(fs.readFileSync(claudeSettingsPath, 'utf-8'));
+        }
+        catch {
+            console.log('  ⚠ Could not parse existing settings.json, creating new one.');
+        }
+    }
+    if (!settings.mcpServers) {
+        settings.mcpServers = {};
+    }
+    const env = {
+        BURNRATE_API_URL: apiUrl
+    };
+    if (apiKey) {
+        env.BURNRATE_API_KEY = apiKey;
+    }
+    settings.mcpServers.burnrate = {
+        command: 'node',
+        args: [mcpServerPath],
+        env
+    };
+    // Ensure directory exists
+    if (!fs.existsSync(claudeSettingsDir)) {
+        fs.mkdirSync(claudeSettingsDir, { recursive: true });
+    }
+    fs.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2));
+    console.log(`\n✓ Claude Code MCP settings written to ${claudeSettingsPath}`);
+    // 7. Summary
+    console.log(`
+╔══════════════════════════════════════════════════════════════╗
+║                     SETUP COMPLETE                           ║
+╠══════════════════════════════════════════════════════════════╣
+║                                                              ║
+║  Restart Claude Code to load the MCP server.                 ║
+║                                                              ║
+║  Then ask Claude:                                            ║
+║    "Use burnrate_join to create a character named MyName"    ║
+║                                                              ║
+║  Or if you already have an API key:                          ║
+║    "Use burnrate_status to see my inventory"                 ║
+║                                                              ║
+╚══════════════════════════════════════════════════════════════╝
+`);
+    rl.close();
+}
+main().catch((err) => {
+    console.error('Setup failed:', err);
+    rl.close();
+    process.exit(1);
+});

package/dist/core/async-engine.d.ts

@@ -0,0 +1,411 @@
+/**
+ * BURNRATE Async Game Engine
+ * Multiplayer-ready engine using TursoDatabase
+ */
+import { TursoDatabase } from '../db/turso-database.js';
+import { Player, Shipment, Unit, MarketOrder, Contract, GameEvent, getZoneEfficiency, Inventory, Resource, IntelReportWithFreshness, ContractType, FactionRank, Faction, ShipmentType, LICENSE_REQUIREMENTS, SeasonScore, TUTORIAL_CONTRACTS } from './types.js';
+export declare class AsyncGameEngine {
+    private db;
+    constructor(db: TursoDatabase);
+    processTick(): Promise<{
+        tick: number;
+        events: GameEvent[];
+    }>;
+    private processSupplyBurn;
+    private processShipments;
+    private completeShipment;
+    private checkInterception;
+    private getRaidersOnRoute;
+    private interceptShipment;
+    private processUnitMaintenance;
+    private processContractExpiration;
+    private resetDailyActions;
+    private processFieldRegeneration;
+    private processStockpileDecay;
+    canPlayerAct(playerId: string): Promise<{
+        allowed: boolean;
+        reason?: string;
+    }>;
+    recordPlayerAction(playerId: string): Promise<void>;
+    createShipmentWithPath(playerId: string, type: 'courier' | 'freight' | 'convoy', path: string[], cargo: Partial<Inventory>): Promise<{
+        success: boolean;
+        shipment?: Shipment;
+        error?: string;
+    }>;
+    placeOrder(playerId: string, zoneId: string, resource: Resource, side: 'buy' | 'sell', price: number, quantity: number): Promise<{
+        success: boolean;
+        order?: MarketOrder;
+        error?: string;
+    }>;
+    private matchOrders;
+    private executeTrade;
+    depositSU(playerId: string, zoneId: string, amount: number): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    depositStockpile(playerId: string, zoneId: string, resource: 'medkits' | 'comms', amount: number): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getZoneEfficiency(zoneId: string): Promise<{
+        success: boolean;
+        efficiency?: ReturnType<typeof getZoneEfficiency>;
+        error?: string;
+    }>;
+    scan(playerId: string, targetType: 'zone' | 'route', targetId: string): Promise<{
+        success: boolean;
+        intel?: any;
+        error?: string;
+    }>;
+    produce(playerId: string, output: string, quantity: number): Promise<{
+        success: boolean;
+        produced?: number;
+        units?: Unit[];
+        error?: string;
+    }>;
+    extract(playerId: string, quantity: number): Promise<{
+        success: boolean;
+        extracted?: {
+            resource: string;
+            amount: number;
+        };
+        error?: string;
+    }>;
+    captureZone(playerId: string, zoneId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    assignEscort(playerId: string, unitId: string, shipmentId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    listUnitForSale(playerId: string, unitId: string, price: number): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    unlistUnit(playerId: string, unitId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    hireUnit(playerId: string, unitId: string): Promise<{
+        success: boolean;
+        unit?: Unit;
+        error?: string;
+    }>;
+    deployRaider(playerId: string, unitId: string, routeId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    createFaction(playerId: string, name: string, tag: string): Promise<{
+        success: boolean;
+        faction?: any;
+        error?: string;
+    }>;
+    joinFaction(playerId: string, factionId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    leaveFaction(playerId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getFactionIntel(playerId: string): Promise<{
+        success: boolean;
+        intel?: IntelReportWithFreshness[];
+        error?: string;
+    }>;
+    /**
+     * Promote a faction member to a higher rank
+     */
+    promoteFactionMember(playerId: string, targetPlayerId: string, newRank: FactionRank): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Demote a faction member to a lower rank
+     */
+    demoteFactionMember(playerId: string, targetPlayerId: string, newRank: FactionRank): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Kick a member from the faction
+     */
+    kickFactionMember(playerId: string, targetPlayerId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Transfer faction leadership to another member
+     */
+    transferFactionLeadership(playerId: string, targetPlayerId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Deposit resources to faction treasury
+     */
+    depositToTreasury(playerId: string, resources: Partial<Record<keyof Inventory, number>>): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Withdraw resources from faction treasury
+     */
+    withdrawFromTreasury(playerId: string, resources: Partial<Record<keyof Inventory, number>>): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get faction details (for members)
+     */
+    getFactionDetails(playerId: string): Promise<{
+        success: boolean;
+        faction?: Faction;
+        myRank?: FactionRank;
+        error?: string;
+    }>;
+    /**
+     * Get available licenses and their requirements
+     */
+    getLicenseStatus(playerId: string): Promise<{
+        success: boolean;
+        licenses?: {
+            type: ShipmentType;
+            unlocked: boolean;
+            requirements: typeof LICENSE_REQUIREMENTS[ShipmentType];
+            canUnlock: boolean;
+        }[];
+        error?: string;
+    }>;
+    /**
+     * Award reputation to a player (can be positive or negative)
+     */
+    private awardReputation;
+    /**
+     * Get player reputation details
+     */
+    /**
+     * Get current season information
+     */
+    getSeasonStatus(): Promise<{
+        seasonNumber: number;
+        week: number;
+        ticksUntilWeekEnd: number;
+        ticksUntilSeasonEnd: number;
+    }>;
+    /**
+     * Get season leaderboard
+     */
+    getLeaderboard(seasonNumber?: number, entityType?: 'player' | 'faction', limit?: number): Promise<{
+        success: boolean;
+        leaderboard?: SeasonScore[];
+        season?: number;
+        error?: string;
+    }>;
+    /**
+     * Get a player's season score
+     */
+    getPlayerSeasonScore(playerId: string, seasonNumber?: number): Promise<{
+        success: boolean;
+        score?: SeasonScore | null;
+        rank?: number;
+        error?: string;
+    }>;
+    getReputationDetails(playerId: string): Promise<{
+        success: boolean;
+        reputation?: number;
+        title?: string;
+        nextTitle?: {
+            title: string;
+            threshold: number;
+            remaining: number;
+        } | null;
+        error?: string;
+    }>;
+    /**
+     * Unlock a license for a player
+     */
+    unlockLicense(playerId: string, licenseType: ShipmentType): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get a player's personal intel with freshness decay applied
+     */
+    getPlayerIntel(playerId: string, limit?: number): Promise<{
+        success: boolean;
+        intel?: IntelReportWithFreshness[];
+        error?: string;
+    }>;
+    /**
+     * Get the most recent intel on a specific target
+     */
+    getTargetIntel(playerId: string, targetType: 'zone' | 'route', targetId: string): Promise<{
+        success: boolean;
+        intel?: IntelReportWithFreshness | null;
+        error?: string;
+    }>;
+    /**
+     * Create a new contract
+     */
+    createContract(playerId: string, type: ContractType, details: {
+        fromZoneId?: string;
+        toZoneId?: string;
+        resource?: Resource;
+        quantity?: number;
+        targetType?: 'zone' | 'route';
+        targetId?: string;
+    }, reward: number, deadline: number, bonus?: {
+        deadline: number;
+        credits: number;
+    }): Promise<{
+        success: boolean;
+        contract?: Contract;
+        error?: string;
+    }>;
+    /**
+     * Accept a contract
+     */
+    acceptContract(playerId: string, contractId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Complete a contract (called when conditions are met)
+     */
+    completeContract(playerId: string, contractId: string): Promise<{
+        success: boolean;
+        reward?: {
+            credits: number;
+            reputation: number;
+        };
+        bonus?: boolean;
+        error?: string;
+    }>;
+    /**
+     * Cancel a contract (poster only, before acceptance)
+     */
+    cancelContract(playerId: string, contractId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get contracts related to a player
+     */
+    getMyContracts(playerId: string): Promise<{
+        success: boolean;
+        contracts?: Contract[];
+        error?: string;
+    }>;
+    /**
+     * Verify if a contract's conditions have been met
+     */
+    private verifyContractCompletion;
+    travel(playerId: string, toZoneId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    private findRoute;
+    private recordEvent;
+    getTutorialStatus(playerId: string): Promise<{
+        success: boolean;
+        step?: number;
+        total?: number;
+        currentContract?: typeof TUTORIAL_CONTRACTS[number] | null;
+        error?: string;
+    }>;
+    completeTutorialStep(playerId: string, step: number): Promise<{
+        success: boolean;
+        step?: number;
+        reward?: {
+            credits: number;
+            reputation: number;
+        };
+        error?: string;
+    }>;
+    ensureStarterFaction(): Promise<void>;
+    createDoctrine(playerId: string, title: string, content: string): Promise<{
+        success: boolean;
+        doctrine?: any;
+        error?: string;
+    }>;
+    getFactionDoctrines(playerId: string): Promise<{
+        success: boolean;
+        doctrines?: any[];
+        error?: string;
+    }>;
+    updateDoctrine(playerId: string, doctrineId: string, content: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    deleteDoctrine(playerId: string, doctrineId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    createConditionalOrder(playerId: string, zoneId: string, resource: string, side: string, triggerPrice: number, quantity: number, condition: string): Promise<{
+        success: boolean;
+        order?: any;
+        error?: string;
+    }>;
+    createTimeWeightedOrder(playerId: string, zoneId: string, resource: string, side: string, price: number, totalQuantity: number, quantityPerTick: number): Promise<{
+        success: boolean;
+        order?: any;
+        error?: string;
+    }>;
+    processConditionalOrders(tick: number): Promise<void>;
+    processTimeWeightedOrders(tick: number): Promise<void>;
+    private processAdvancedOrders;
+    registerWebhook(playerId: string, url: string, events: string[]): Promise<{
+        success: boolean;
+        webhook?: any;
+        error?: string;
+    }>;
+    getWebhooks(playerId: string): Promise<{
+        success: boolean;
+        webhooks?: any[];
+        error?: string;
+    }>;
+    deleteWebhook(playerId: string, webhookId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    triggerWebhooks(eventType: string, data: any): Promise<void>;
+    exportPlayerData(playerId: string): Promise<{
+        success: boolean;
+        data?: {
+            player: Player;
+            units: Unit[];
+            shipments: Shipment[];
+            contracts: Contract[];
+            intel: IntelReportWithFreshness[];
+            events: GameEvent[];
+        };
+        error?: string;
+    }>;
+    executeBatch(playerId: string, operations: Array<{
+        action: string;
+        params: any;
+    }>): Promise<{
+        success: boolean;
+        results?: Array<{
+            action: string;
+            result: any;
+        }>;
+        error?: string;
+    }>;
+    getFactionAnalytics(playerId: string): Promise<{
+        success: boolean;
+        analytics?: {
+            members: any[];
+            zones: any[];
+            activity: any[];
+        };
+        error?: string;
+    }>;
+    getFactionAuditLogs(playerId: string, limit?: number): Promise<{
+        success: boolean;
+        logs?: any[];
+        error?: string;
+    }>;
+}