roguelike-cli 1.3.0 → 1.3.2

package/dist/interactive/commands.js

@@ -428,6 +428,13 @@ async function processCommand(input, currentPath, config, signal, rl) {
         // Update profile with XP and achievements
         const depth = getDepth(currentPath, config.storagePath);
         const taskResult = (0, profile_1.completeTask)(result.xpGained, nodeConfig.isBoss || false, depth, nodeConfig.createdAt);
+        // Save to undo history
+        (0, profile_1.addToUndoHistory)({
+            path: currentPath,
+            xpLost: result.xpGained,
+            wasBoss: nodeConfig.isBoss || false,
+            timestamp: new Date().toISOString(),
+        });
         let output = `\n=== TASK COMPLETED ===\n`;
         output += `\nTasks completed: ${result.tasksCompleted}`;
         if (result.bossesDefeated > 0) {
@@ -445,6 +452,30 @@ async function processCommand(input, currentPath, config, signal, rl) {
             }
         }
         output += '\n';
+        output += '[Type "undo" to revert]';
+        return wrapResult({ output });
+    }
+    // Undo command
+    if (command === 'undo') {
+        const lastUndo = (0, profile_1.getLastUndo)();
+        if (!lastUndo) {
+            return wrapResult({ output: 'Nothing to undo.' });
+        }
+        // Revert the task status
+        const nodeConfig = (0, nodeConfig_1.readNodeConfig)(lastUndo.path);
+        if (nodeConfig) {
+            (0, nodeConfig_1.writeNodeConfig)(lastUndo.path, {
+                ...nodeConfig,
+                status: 'open',
+                completedAt: undefined,
+            });
+        }
+        // Revert profile stats
+        const result = (0, profile_1.performUndo)();
+        let output = `\n=== UNDO ===\n`;
+        output += `\nReverted: ${path.basename(lastUndo.path)}`;
+        output += `\n${result.message}`;
+        output += '\n';
         return wrapResult({ output });
     }
     // Deadline command
@@ -482,19 +513,48 @@ async function processCommand(input, currentPath, config, signal, rl) {
         });
         return wrapResult({ output: newIsBoss ? 'Marked as BOSS task (3x XP)' : 'Removed BOSS status' });
     }
-    // Block command
+    // Block command - block <node> or block "reason"
     if (command === 'block') {
         const nodeConfig = (0, nodeConfig_1.readNodeConfig)(currentPath);
         if (!nodeConfig) {
             return wrapResult({ output: 'No task at current location.' });
         }
-        const reason = parts.length > 1 ? parts.slice(1).join(' ') : undefined;
+        const arg = parts.length > 1 ? parts.slice(1).join(' ') : undefined;
+        let blockedBy = nodeConfig.blockedBy || [];
+        let blockMessage = 'Task marked as blocked';
+        if (arg) {
+            // Check if it's a path to another node
+            const potentialPath = path.join(currentPath, '..', arg);
+            const absolutePath = path.isAbsolute(arg) ? arg : potentialPath;
+            if (fs.existsSync(absolutePath) && fs.statSync(absolutePath).isDirectory()) {
+                // It's a node path
+                const blockerConfig = (0, nodeConfig_1.readNodeConfig)(absolutePath);
+                const blockerName = blockerConfig?.name || path.basename(absolutePath);
+                blockedBy = [...blockedBy, absolutePath];
+                blockMessage = `Blocked by: ${blockerName}`;
+            }
+            else {
+                // Check sibling folder
+                const siblingPath = path.join(path.dirname(currentPath), arg);
+                if (fs.existsSync(siblingPath) && fs.statSync(siblingPath).isDirectory()) {
+                    const blockerConfig = (0, nodeConfig_1.readNodeConfig)(siblingPath);
+                    const blockerName = blockerConfig?.name || arg;
+                    blockedBy = [...blockedBy, siblingPath];
+                    blockMessage = `Blocked by: ${blockerName}`;
+                }
+                else {
+                    // It's a text reason
+                    blockedBy = [...blockedBy, arg];
+                    blockMessage = `Blocked: ${arg}`;
+                }
+            }
+        }
         (0, nodeConfig_1.writeNodeConfig)(currentPath, {
             ...nodeConfig,
             status: 'blocked',
-            blockedBy: reason ? [reason] : nodeConfig.blockedBy,
+            blockedBy,
         });
-        return wrapResult({ output: reason ? `Blocked: ${reason}` : 'Task marked as blocked' });
+        return wrapResult({ output: blockMessage });
     }
     // Unblock command
     if (command === 'unblock') {
@@ -509,6 +569,67 @@ async function processCommand(input, currentPath, config, signal, rl) {
         });
         return wrapResult({ output: 'Task unblocked' });
     }
+    // Check command - show overdue/upcoming deadlines
+    if (command === 'check') {
+        const checkDeadlines = (dirPath, results) => {
+            if (!fs.existsSync(dirPath))
+                return;
+            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory() || entry.name.startsWith('.'))
+                    continue;
+                const nodePath = path.join(dirPath, entry.name);
+                const cfg = (0, nodeConfig_1.readNodeConfig)(nodePath);
+                if (cfg && cfg.deadline && cfg.status !== 'done') {
+                    const deadlineDate = new Date(cfg.deadline);
+                    const today = new Date();
+                    today.setHours(0, 0, 0, 0);
+                    deadlineDate.setHours(0, 0, 0, 0);
+                    const diffDays = Math.ceil((deadlineDate.getTime() - today.getTime()) / (1000 * 60 * 60 * 24));
+                    if (diffDays <= 3) { // Show tasks due within 3 days or overdue
+                        results.push({
+                            path: nodePath,
+                            name: cfg.name,
+                            deadline: formatDeadline(cfg.deadline),
+                            status: diffDays < 0 ? 'OVERDUE' : diffDays === 0 ? 'TODAY' : 'SOON',
+                        });
+                    }
+                }
+                checkDeadlines(nodePath, results);
+            }
+        };
+        const results = [];
+        checkDeadlines(config.storagePath, results);
+        if (results.length === 0) {
+            return wrapResult({ output: 'No upcoming deadlines within 3 days.' });
+        }
+        const lines = ['', '=== DEADLINE CHECK ===', ''];
+        const overdue = results.filter(r => r.status === 'OVERDUE');
+        const today = results.filter(r => r.status === 'TODAY');
+        const soon = results.filter(r => r.status === 'SOON');
+        if (overdue.length > 0) {
+            lines.push('OVERDUE:');
+            for (const r of overdue) {
+                lines.push(`  ! ${r.name} (${r.deadline})`);
+            }
+            lines.push('');
+        }
+        if (today.length > 0) {
+            lines.push('DUE TODAY:');
+            for (const r of today) {
+                lines.push(`  * ${r.name}`);
+            }
+            lines.push('');
+        }
+        if (soon.length > 0) {
+            lines.push('UPCOMING:');
+            for (const r of soon) {
+                lines.push(`  - ${r.name} (${r.deadline})`);
+            }
+            lines.push('');
+        }
+        return wrapResult({ output: lines.join('\n') });
+    }
     // Status command - show current task status
     if (command === 'status') {
         const nodeConfig = (0, nodeConfig_1.readNodeConfig)(currentPath);
@@ -531,7 +652,15 @@ async function processCommand(input, currentPath, config, signal, rl) {
             lines.push(`Completed: ${new Date(nodeConfig.completedAt).toLocaleDateString()}`);
         }
         if (nodeConfig.blockedBy && nodeConfig.blockedBy.length > 0) {
-            lines.push(`Blocked by: ${nodeConfig.blockedBy.join(', ')}`);
+            // Format blockedBy - show names if paths exist
+            const blockerNames = nodeConfig.blockedBy.map(b => {
+                if (fs.existsSync(b)) {
+                    const cfg = (0, nodeConfig_1.readNodeConfig)(b);
+                    return cfg?.name || path.basename(b);
+                }
+                return b;
+            });
+            lines.push(`Blocked by: ${blockerNames.join(', ')}`);
         }
         lines.push('');
         return wrapResult({ output: lines.join('\n') });
@@ -802,36 +931,67 @@ async function processCommand(input, currentPath, config, signal, rl) {
         return wrapResult({ output: currentPath });
     }
     if (command === 'config') {
+        const { updateConfig, RULES_PRESETS } = await Promise.resolve().then(() => __importStar(require('../config/config')));
+        // Check for flags
+        const keyFlag = parts.find(p => p.startsWith('-k=') || p.startsWith('--key='));
+        const modelFlag = parts.find(p => p.startsWith('-m=') || p.startsWith('--model='));
+        const rulesFlag = parts.find(p => p.startsWith('-r=') || p.startsWith('--rules='));
+        const themeFlag = parts.find(p => p.startsWith('-t=') || p.startsWith('--theme='));
+        if (keyFlag) {
+            const value = keyFlag.split('=').slice(1).join('=');
+            updateConfig({ apiKey: value });
+            return wrapResult({ output: 'API key updated.' });
+        }
+        if (modelFlag) {
+            const value = modelFlag.split('=').slice(1).join('=');
+            updateConfig({ model: value });
+            return wrapResult({ output: `Model updated: ${value}` });
+        }
+        if (rulesFlag) {
+            const value = rulesFlag.split('=').slice(1).join('=');
+            updateConfig({ rules: value, rulesPreset: 'custom' });
+            return wrapResult({ output: 'Custom rules updated.' });
+        }
+        if (themeFlag) {
+            const value = themeFlag.split('=').slice(1).join('=').toLowerCase();
+            if (RULES_PRESETS[value]) {
+                updateConfig({
+                    rules: RULES_PRESETS[value].rules,
+                    rulesPreset: value
+                });
+                return wrapResult({ output: `Theme updated: ${RULES_PRESETS[value].name}` });
+            }
+            else {
+                const themes = Object.keys(RULES_PRESETS).join(', ');
+                return wrapResult({ output: `Unknown theme. Available: ${themes}` });
+            }
+        }
+        // Show config
         const maskedKey = config.apiKey
             ? config.apiKey.slice(0, 8) + '...' + config.apiKey.slice(-4)
             : '(not set)';
+        const themeName = config.rulesPreset
+            ? (RULES_PRESETS[config.rulesPreset]?.name || 'Custom')
+            : 'Default';
+        const rulesPreview = config.rules
+            ? (config.rules.length > 50 ? config.rules.substring(0, 50) + '...' : config.rules)
+            : '(none)';
         const output = `
 Provider:     ${config.aiProvider}
 Model:        ${config.model || '(default)'}
 API Key:      ${maskedKey}
 Storage:      ${config.storagePath}
+Theme:        ${themeName}
+Rules:        ${rulesPreview}
+
+Set with flags:
+  config -k=<key>       Set API key
+  config -m=<model>     Set model
+  config -t=<theme>     Set theme (fantasy, space, starwars, western, cyberpunk, pirate)
+  config -r="<rules>"   Set custom rules
 `.trim();
         return wrapResult({ output });
     }
-    if (command.startsWith('config:')) {
-        const configParts = input.split(':').slice(1).join(':').trim().split('=');
-        if (configParts.length !== 2) {
-            return { output: 'Usage: config:key=value' };
-        }
-        const key = configParts[0].trim();
-        const value = configParts[1].trim();
-        if (key === 'apiKey') {
-            const { updateConfig } = await Promise.resolve().then(() => __importStar(require('../config/config')));
-            updateConfig({ apiKey: value });
-            return { output: 'API key updated.' };
-        }
-        if (key === 'storagePath') {
-            const { updateConfig } = await Promise.resolve().then(() => __importStar(require('../config/config')));
-            updateConfig({ storagePath: value, currentPath: value });
-            return { output: `Storage path updated to: ${value}` };
-        }
-        return { output: `Unknown config key: ${key}` };
-    }
     if (command === 'help') {
         return wrapResult({
             output: `
@@ -839,9 +999,7 @@ Storage:      ${config.storagePath}
 
 Navigation:
   ls                    List tasks and files
-  tree                  Show task tree with status
-  tree -A               Include files
-  tree --depth=N        Limit tree depth
+  tree [-A] [--depth=N] Show task tree
   cd <task>             Navigate into task
   cd .., ...            Go back 1 or 2 levels
   pwd                   Show current path
@@ -849,47 +1007,43 @@ Navigation:
 
 Task Management:
   mkdir <name>          Create new task
-  done                  Mark current task as completed (recursive)
-  deadline <date>       Set deadline (today, tomorrow, +3d, Jan 15)
-  boss                  Toggle boss/milestone status (3x XP)
-  block [reason]        Mark task as blocked
-  unblock               Remove blocked status
-  status                Show current task details
-
-File Operations:
-  cp <src> <dest>       Copy file or folder
-  mv <src> <dest>       Move/rename
-  rm <name>             Delete file
-  rm -rf <name>         Delete folder
+  done                  Complete task (earns XP)
+  undo                  Undo last done
+  deadline <date>       Set deadline (today, +3d, Jan 15)
+  boss                  Toggle boss status (3x XP)
+  block [node]          Block by task or text
+  unblock               Remove block
+  status                Task details
+  check                 Upcoming deadlines
 
 Gamification:
-  stats                 Show XP, level, streaks
-  achievements          Show achievement list
-  map                   Dungeon map view
-  map --ai              AI-generated dungeon map
-
-Schema Generation:
-  <description>         AI generates todo/schema preview
-  save                  Save pending schema
-  cancel                Discard pending schema
+  stats                 XP, level, streaks
+  achievements          Achievement list
+  map [--ai]            Dungeon map view
 
-Utility:
+Configuration:
   init                  Setup wizard
   config                Show settings
+  config -k=<key>       Set API key
+  config -m=<model>     Set model
+  config -t=<theme>     Set theme (fantasy, space, starwars, etc)
+  config -r="<rules>"   Custom AI rules
+
+Themes:
+  default, fantasy, space, starwars, western, cyberpunk, pirate
+
+File Operations:
+  cp, mv, rm [-rf]      Standard file operations
   clean --yes           Clear current folder
-  v, version            Show version
-  help                  This help
-  exit, quit            Exit
 
-Clipboard:
-  <cmd> | pbcopy        Copy output (macOS)
-  <cmd> | clip          Copy output (Windows)
+AI Generation:
+  <description>         AI generates preview
+  save                  Save to folders/file
+  cancel                Discard
 
-Deadlines:
-  deadline today        Due today
-  deadline tomorrow     Due tomorrow
-  deadline +3d          Due in 3 days
-  deadline Jan 15       Due on date
+Clipboard:
+  <cmd> | pbcopy        Copy to clipboard (macOS)
+  <cmd> | clip          Copy to clipboard (Windows)
 
 www.rlc.rocks
 `.trim()

package/dist/interactive/startup.js

@@ -19,16 +19,16 @@ const ASCII_ART = [
     '║      Roguelike CLI      ║',
     '╚═════════════════════════╝',
     '',
-    '  Navigation: ls, cd, tree, pwd, open',
-    '  Tasks: done, deadline, boss, block, status',
-    '  Gamification: stats, achievements, map',
+    '  Tasks: done, undo, deadline, boss, block',
+    '  Stats: stats, achievements, map, check',
+    '  Config: init, config -t=<theme>',
     '',
-    '  TAB to autocomplete, | pbcopy to copy',
-    '  Workflow: <description> -> refine -> save',
+    '  Themes: fantasy, space, starwars, cyberpunk',
     '',
-    '  help - all commands, init - setup',
+    '  TAB autocomplete, | pbcopy to copy',
+    '  <description> -> refine -> save',
     '',
-    '  www.rlc.rocks',
+    '  help - commands, www.rlc.rocks',
     '',
     '  Ready...',
     '',

package/dist/storage/profile.js

@@ -43,6 +43,9 @@ exports.addXP = addXP;
 exports.completeTask = completeTask;
 exports.formatStats = formatStats;
 exports.formatAchievements = formatAchievements;
+exports.addToUndoHistory = addToUndoHistory;
+exports.getLastUndo = getLastUndo;
+exports.performUndo = performUndo;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
@@ -127,6 +130,7 @@ function createDefaultProfile() {
         currentStreak: 0,
         longestStreak: 0,
         achievements: [],
+        undoHistory: [],
         stats: {
             completedByDay: {},
             createdAt: new Date().toISOString(),
@@ -274,3 +278,46 @@ function formatAchievements() {
     lines.push('');
     return lines.join('\n');
 }
+function addToUndoHistory(entry) {
+    const profile = readProfile();
+    // Keep only last 10 undo entries
+    profile.undoHistory = profile.undoHistory || [];
+    profile.undoHistory.unshift(entry);
+    if (profile.undoHistory.length > 10) {
+        profile.undoHistory = profile.undoHistory.slice(0, 10);
+    }
+    saveProfile(profile);
+}
+function getLastUndo() {
+    const profile = readProfile();
+    if (!profile.undoHistory || profile.undoHistory.length === 0) {
+        return null;
+    }
+    return profile.undoHistory[0];
+}
+function performUndo() {
+    const profile = readProfile();
+    if (!profile.undoHistory || profile.undoHistory.length === 0) {
+        return { success: false, entry: null, message: 'Nothing to undo.' };
+    }
+    const entry = profile.undoHistory.shift();
+    // Subtract XP
+    profile.totalXP = Math.max(0, profile.totalXP - entry.xpLost);
+    profile.tasksCompleted = Math.max(0, profile.tasksCompleted - 1);
+    if (entry.wasBoss) {
+        profile.bossesDefeated = Math.max(0, profile.bossesDefeated - 1);
+    }
+    // Update level
+    profile.level = levelFromXP(profile.totalXP);
+    // Update daily stats
+    const today = new Date().toISOString().split('T')[0];
+    if (profile.stats.completedByDay[today]) {
+        profile.stats.completedByDay[today] = Math.max(0, profile.stats.completedByDay[today] - 1);
+    }
+    saveProfile(profile);
+    return {
+        success: true,
+        entry,
+        message: `Undo: -${entry.xpLost} XP`
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roguelike-cli",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "AI-powered interactive terminal for creating schemas and todo lists",
   "main": "dist/index.js",
   "bin": {

package/src/ai/claude.ts

@@ -60,7 +60,7 @@ export async function generateSchemaWithAI(
   history?: ConversationMessage[]
 ): Promise<GeneratedSchema | null> {
   if (!config.apiKey) {
-    throw new Error('API key not set. Use config:apiKey=<key> to set it.');
+    throw new Error('API key not set. Use config -k=<key> to set it.');
   }
   
   const client = new Anthropic({
@@ -87,10 +87,17 @@ export async function generateSchemaWithAI(
 
   try {
     const model = config.model || 'claude-sonnet-4-20250514';
+    
+    // Build system prompt with custom rules
+    let systemPrompt = SYSTEM_PROMPT;
+    if (config.rules) {
+      systemPrompt += '\n\nADDITIONAL STYLE RULES (apply to all responses):\n' + config.rules;
+    }
+    
     const message = await client.messages.create({
       model: model,
       max_tokens: 2000,
-      system: SYSTEM_PROMPT,
+      system: systemPrompt,
       messages: messages,
     });
     
@@ -126,7 +133,7 @@ export async function generateDungeonMapWithAI(
   signal?: AbortSignal
 ): Promise<string | null> {
   if (!config.apiKey) {
-    throw new Error('API key not set. Use config:apiKey=<key> to set it.');
+    throw new Error('API key not set. Use config -k=<key> to set it.');
   }
   
   const client = new Anthropic({
@@ -135,10 +142,17 @@ export async function generateDungeonMapWithAI(
 
   try {
     const model = config.model || 'claude-sonnet-4-20250514';
+    
+    // Build system prompt with custom rules
+    let systemPrompt = DUNGEON_MAP_PROMPT;
+    if (config.rules) {
+      systemPrompt += '\n\nADDITIONAL STYLE RULES:\n' + config.rules;
+    }
+    
     const message = await client.messages.create({
       model: model,
       max_tokens: 2000,
-      system: DUNGEON_MAP_PROMPT,
+      system: systemPrompt,
       messages: [{
         role: 'user',
         content: 'Generate a dungeon map for this task tree:\n\n' + treeContent

package/src/commands/init.ts

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import * as readline from 'readline';
-import { Config, saveConfig, initConfig } from '../config/config';
+import { Config, saveConfig, initConfig, RULES_PRESETS } from '../config/config';
 
 function question(rl: readline.Interface, query: string): Promise<string> {
   return new Promise((resolve) => {
@@ -31,7 +31,6 @@ function copyRecursive(src: string, dest: string): void {
 }
 
 export async function initCommand(existingRl?: readline.Interface): Promise<void> {
-  // Create our own readline if not provided, or use existing one
   const rl = existingRl || readline.createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -44,7 +43,6 @@ export async function initCommand(existingRl?: readline.Interface): Promise<void
     console.log('║   ROGUELIKE CLI INITIALIZATION WIZARD ║');
     console.log('╚═══════════════════════════════════════╝\n');
 
-    // Get existing config if any
     const existingConfig = await initConfig();
     const oldStoragePath = existingConfig?.storagePath;
 
@@ -101,7 +99,7 @@ export async function initCommand(existingRl?: readline.Interface): Promise<void
 
     console.log(`Selected: ${selectedProvider.name} (${selectedProvider.model})`);
 
-    // 3. API Key - reuse existing if not provided
+    // 3. API Key
     const existingApiKey = existingConfig?.apiKey || '';
     const hasExistingKey = existingApiKey.length > 0;
     const keyPrompt = hasExistingKey 
@@ -112,13 +110,49 @@ export async function initCommand(existingRl?: readline.Interface): Promise<void
     const apiKey = apiKeyInput.trim() || existingApiKey;
     
     if (!apiKey) {
-      console.log('Warning: API key not set. You can set it later with config:apiKey=<key>');
+      console.log('Warning: API key not set. You can set it later with: config -k <key>');
     } else if (apiKeyInput.trim()) {
       console.log('API key saved');
     } else {
       console.log('Using existing API key');
     }
 
+    // 4. Theme/Rules selection
+    console.log('\nSelect AI Theme (affects language style):');
+    const presetKeys = Object.keys(RULES_PRESETS);
+    presetKeys.forEach((key, index) => {
+      console.log(`  ${index + 1}. ${RULES_PRESETS[key].name}`);
+    });
+    console.log(`  ${presetKeys.length + 1}. Custom (enter your own rules)`);
+
+    const existingPreset = existingConfig?.rulesPreset || 'default';
+    const defaultPresetIndex = presetKeys.indexOf(existingPreset) + 1 || 1;
+    
+    const themeChoice = await question(rl, `\nEnter choice [1-${presetKeys.length + 1}] (default: ${defaultPresetIndex}): `);
+    const themeIndex = parseInt(themeChoice.trim()) - 1;
+    
+    let selectedRules = '';
+    let selectedPreset = 'default';
+    
+    if (themeIndex >= 0 && themeIndex < presetKeys.length) {
+      selectedPreset = presetKeys[themeIndex];
+      selectedRules = RULES_PRESETS[selectedPreset].rules;
+      console.log(`Selected: ${RULES_PRESETS[selectedPreset].name}`);
+    } else if (themeIndex === presetKeys.length) {
+      // Custom rules
+      console.log('\nEnter your custom rules for AI (how it should speak, what terms to use):');
+      console.log('Example: "Use pirate language. Tasks are treasure hunts. Be playful."');
+      const customRules = await question(rl, '\nYour rules: ');
+      selectedRules = customRules.trim();
+      selectedPreset = 'custom';
+      console.log('Custom rules saved');
+    } else {
+      // Default
+      selectedPreset = existingConfig?.rulesPreset || 'default';
+      selectedRules = existingConfig?.rules || '';
+      console.log(`Keeping: ${RULES_PRESETS[selectedPreset]?.name || 'Default'}`);
+    }
+
     // Save config
     const config: Config = {
       aiProvider: selectedProvider.name as any,
@@ -127,11 +161,12 @@ export async function initCommand(existingRl?: readline.Interface): Promise<void
       storagePath: rootDir,
       currentPath: rootDir,
       model: selectedProvider.model,
+      rules: selectedRules,
+      rulesPreset: selectedPreset,
     };
 
     saveConfig(config);
     
-    // Ensure storage directory exists
     if (!fs.existsSync(rootDir)) {
       fs.mkdirSync(rootDir, { recursive: true });
     }
@@ -141,7 +176,8 @@ export async function initCommand(existingRl?: readline.Interface): Promise<void
     console.log('╚═══════════════════════════════════════╝\n');
     console.log(`Root directory: ${rootDir}`);
     console.log(`AI Provider: ${selectedProvider.name}`);
-    console.log(`Model: ${selectedProvider.model}\n`);
+    console.log(`Model: ${selectedProvider.model}`);
+    console.log(`Theme: ${RULES_PRESETS[selectedPreset]?.name || 'Custom'}\n`);
   } finally {
     if (shouldCloseRl) {
       rl.close();

package/src/config/config.ts

@@ -9,8 +9,42 @@ export interface Config {
   storagePath: string;
   currentPath: string;
   model?: string;
+  rules?: string;
+  rulesPreset?: string;
 }
 
+// Preset rules for different themes
+export const RULES_PRESETS: Record<string, { name: string; rules: string }> = {
+  default: {
+    name: 'Default (No theme)',
+    rules: '',
+  },
+  fantasy: {
+    name: 'Fantasy RPG',
+    rules: 'Use fantasy RPG language. Tasks are "quests", completing them is "slaying". Major milestones are "boss battles". Use terms like "adventurer", "dungeon", "loot", "guild". Add flavor text with swords, dragons, magic.',
+  },
+  space: {
+    name: 'Space Opera',
+    rules: 'Use sci-fi space language. Tasks are "missions", completing them is "mission accomplished". Major milestones are "final frontier". Use terms like "commander", "starship", "coordinates", "hyperdrive". Add flavor with stars, planets, aliens.',
+  },
+  starwars: {
+    name: 'Star Wars',
+    rules: 'Use Star Wars language. Tasks are "missions from the Rebel Alliance". Completing is "defeating the Empire". Milestones are "destroying the Death Star". Use "Jedi", "Force", "Padawan", "Master". May the Force be with you.',
+  },
+  western: {
+    name: 'Wild West',
+    rules: 'Use Wild West language. Tasks are "bounties", completing them is "collecting the reward". Milestones are "showdowns". Use terms like "sheriff", "outlaw", "saloon", "frontier", "partner". Add dusty trails and tumbleweeds.',
+  },
+  cyberpunk: {
+    name: 'Cyberpunk',
+    rules: 'Use cyberpunk language. Tasks are "gigs", completing them is "flatlined". Milestones are "megacorp takedowns". Use terms like "netrunner", "chrome", "corpo", "edgerunner", "eddies". Add neon and rain.',
+  },
+  pirate: {
+    name: 'Pirate',
+    rules: 'Use pirate language. Tasks are "plunder", completing them is "claiming the treasure". Milestones are "capturing the flagship". Use "captain", "crew", "booty", "seven seas", "landlubber". Arr matey!',
+  },
+};
+
 const CONFIG_FILE = path.join(os.homedir(), '.rlc', 'config.json');
 const DEFAULT_STORAGE = path.join(os.homedir(), '.rlc', 'workspace');