roguelike-cli 1.0.0

package/INSTALL.md

@@ -0,0 +1,108 @@
+# Roguelike CLI - Installation Guide
+
+## Local Development Setup
+
+1. Install dependencies:
+```bash
+cd cli
+npm install
+```
+
+2. Build the project:
+```bash
+npm run build
+```
+
+3. Link locally for testing:
+```bash
+npm link
+```
+
+This will make `rlc` command available globally.
+
+4. Test the installation:
+```bash
+rlc
+```
+
+## First Run
+
+Run `init` to configure:
+```bash
+rlc
+> init
+```
+
+Or set API key manually:
+```bash
+> config:apiKey=your-api-key-here
+```
+
+## How to Use
+
+### View config
+```bash
+> config
+Provider:     claude
+Model:        claude-sonnet-4-20250514
+API Key:      sk-ant-a...1234
+Storage:      /Users/you/.rlc/notes
+```
+
+### Create schema or todo
+```bash
+> todo opening company in delaware
+> architecture kubernetes cluster with postgres
+```
+
+### Navigation
+```bash
+> ls                    # list files (columns)
+> cd my-project         # go into folder
+> cd ..                 # go back
+> pwd                   # current path
+> tree                  # show tree structure
+> tree -A               # show tree with files
+> tree --depth=2        # limit depth
+> open                  # open folder in Finder
+> open my-folder        # open specific folder
+```
+
+### Copy to clipboard
+Add `| pbcopy` (macOS), `| copy` or `| clip` (Windows) to any command:
+```bash
+> ls | pbcopy
+> tree | pbcopy
+> config | pbcopy
+> pwd | pbcopy
+```
+
+### File operations
+```bash
+> mkdir my-note         # create folder
+> cp source dest        # copy
+> mv source dest        # move/rename
+> rm file               # delete file
+> rm -rf folder         # delete folder
+```
+
+## Uninstall
+
+```bash
+npm unlink -g roguelike-cli
+```
+
+## Troubleshooting
+
+If you get "command not found":
+- Make sure `npm link` was run successfully
+- Check that `~/.npm-global/bin` or similar is in your PATH
+
+If API errors occur:
+- Verify your API key is set: `config`
+- Check that you have credits/access to Claude API
+
+## Website
+
+https://www.rlc.rocks
+

package/bin/rlc

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+require('../dist/index.js');
+

package/dist/ai/claude.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchemaWithAI = generateSchemaWithAI;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const SYSTEM_PROMPT = `You are a schema generator. Based on user input, generate EITHER:
+
+1. **BLOCK DIAGRAM** - when user mentions: "schema", "architecture", "infrastructure", "diagram", "system"
+   Use box-drawing to create visual blocks with connections:
+   
+   Example:
+   \`\`\`
+   ┌─────────────────────────────────────────────────────────────┐
+   │                     Kubernetes Cluster                       │
+   │                                                              │
+   │  ┌──────────────────┐      ┌──────────────────┐            │
+   │  │   Control Plane  │      │   Worker Nodes   │            │
+   │  │                  │◄────►│                  │            │
+   │  │  - API Server    │      │  - Node Pool 1   │            │
+   │  │  - Scheduler     │      │  - Node Pool 2   │            │
+   │  │  - etcd          │      │  - GPU Pool      │            │
+   │  └────────┬─────────┘      └────────┬─────────┘            │
+   │           │                          │                      │
+   │           └──────────┬───────────────┘                      │
+   │                      │                                       │
+   │  ┌──────────────────┐│┌──────────────────┐                 │
+   │  │    PostgreSQL    │││     Redis        │                 │
+   │  └──────────────────┘│└──────────────────┘                 │
+   └─────────────────────────────────────────────────────────────┘
+   \`\`\`
+
+2. **TREE STRUCTURE** - when user mentions: "todo", "tasks", "list", "steps", "plan"
+   Use tree format:
+   
+   Example:
+   \`\`\`
+   ├── Phase 1: Setup
+   │   ├── Create repository
+   │   ├── Setup CI/CD
+   │   └── Configure environment
+   ├── Phase 2: Development
+   │   ├── Backend API
+   │   └── Frontend UI
+   └── Phase 3: Deploy
+   \`\`\`
+
+Rules:
+1. Extract a short title for filename
+2. If user says "schema" or "architecture" - ALWAYS use BLOCK DIAGRAM format
+3. If user says "todo" or "tasks" - use TREE format
+4. Keep context from previous messages
+
+Respond with JSON:
+{
+  "title": "short-title",
+  "format": "block" or "tree",
+  "content": "the actual ASCII art schema here"
+}`;
+async function generateSchemaWithAI(input, config, signal, history) {
+    if (!config.apiKey) {
+        throw new Error('API key not set. Use config:apiKey=<key> to set it.');
+    }
+    const client = new sdk_1.default({
+        apiKey: config.apiKey,
+    });
+    // Build messages from history or just the current input
+    const messages = [];
+    if (history && history.length > 0) {
+        // Add previous messages for context
+        for (const msg of history.slice(0, -1)) { // exclude the last one (current input)
+            messages.push({
+                role: msg.role,
+                content: msg.role === 'assistant'
+                    ? `Previous schema generated:\n${msg.content}`
+                    : msg.content
+            });
+        }
+    }
+    // Add current user input
+    messages.push({
+        role: 'user',
+        content: input
+    });
+    try {
+        const model = config.model || 'claude-sonnet-4-20250514';
+        const message = await client.messages.create({
+            model: model,
+            max_tokens: 2000,
+            system: SYSTEM_PROMPT,
+            messages: messages,
+        });
+        const content = message.content[0];
+        if (content.type !== 'text') {
+            return null;
+        }
+        const text = content.text.trim();
+        let jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            return null;
+        }
+        const parsed = JSON.parse(jsonMatch[0]);
+        // AI now returns ready content
+        const schemaContent = parsed.content || '';
+        return {
+            title: parsed.title || 'schema',
+            content: schemaContent,
+        };
+    }
+    catch (error) {
+        console.error('AI Error:', error.message);
+        return null;
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,175 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const config_1 = require("../config/config");
+function question(query) {
+    return new Promise((resolve) => {
+        process.stdout.write(query);
+        let input = '';
+        const onData = (chunk) => {
+            const str = chunk.toString();
+            for (const char of str) {
+                if (char === '\n' || char === '\r') {
+                    process.stdin.removeListener('data', onData);
+                    process.stdout.write('\n');
+                    resolve(input);
+                    return;
+                }
+                else if (char === '\x7f' || char === '\b') {
+                    // Backspace
+                    if (input.length > 0) {
+                        input = input.slice(0, -1);
+                        process.stdout.write('\b \b');
+                    }
+                }
+                else if (char >= ' ') {
+                    input += char;
+                    process.stdout.write(char);
+                }
+            }
+        };
+        process.stdin.on('data', onData);
+    });
+}
+// Recursive copy function
+function copyRecursive(src, dest) {
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+        if (!fs.existsSync(dest)) {
+            fs.mkdirSync(dest, { recursive: true });
+        }
+        const entries = fs.readdirSync(src);
+        for (const entry of entries) {
+            copyRecursive(path.join(src, entry), path.join(dest, entry));
+        }
+    }
+    else {
+        fs.copyFileSync(src, dest);
+    }
+}
+async function initCommand() {
+    console.log('\n╔═══════════════════════════════════════╗');
+    console.log('║   ROGUELIKE CLI INITIALIZATION WIZARD ║');
+    console.log('╚═══════════════════════════════════════╝\n');
+    // Get existing config if any
+    const existingConfig = await (0, config_1.initConfig)();
+    const oldStoragePath = existingConfig?.storagePath;
+    // 1. Root directory
+    const defaultRoot = path.join(os.homedir(), '.rlc', 'notes');
+    const rootDirAnswer = await question(`Root directory for notes [${defaultRoot}]: `);
+    const rootDir = rootDirAnswer.trim() || defaultRoot;
+    // Check if we need to migrate data
+    if (oldStoragePath && oldStoragePath !== rootDir && fs.existsSync(oldStoragePath)) {
+        const entries = fs.readdirSync(oldStoragePath);
+        if (entries.length > 0) {
+            const migrateAnswer = await question(`\nMigrate existing data from ${oldStoragePath}? [Y/n]: `);
+            if (migrateAnswer.toLowerCase() !== 'n') {
+                if (!fs.existsSync(rootDir)) {
+                    fs.mkdirSync(rootDir, { recursive: true });
+                }
+                console.log(`Migrating data...`);
+                for (const entry of entries) {
+                    const srcPath = path.join(oldStoragePath, entry);
+                    const destPath = path.join(rootDir, entry);
+                    copyRecursive(srcPath, destPath);
+                }
+                console.log(`Migrated ${entries.length} items to ${rootDir}`);
+            }
+        }
+    }
+    if (!fs.existsSync(rootDir)) {
+        fs.mkdirSync(rootDir, { recursive: true });
+        console.log(`Created directory: ${rootDir}`);
+    }
+    // 2. AI Provider selection
+    console.log('\nSelect AI Provider:');
+    console.log('  1. Claude Sonnet 4.5');
+    console.log('  2. Claude Opus 4.5');
+    console.log('  3. GPT-4o (latest)');
+    console.log('  4. Gemini 3 Pro');
+    console.log('  5. Grok (latest)');
+    const aiChoice = await question('\nEnter choice [1-5] (default: 1): ');
+    const aiProviders = [
+        { name: 'claude', model: 'claude-sonnet-4-20250514', apiUrl: 'https://api.anthropic.com' },
+        { name: 'claude-opus', model: 'claude-opus-4-20250514', apiUrl: 'https://api.anthropic.com' },
+        { name: 'openai', model: 'gpt-4o', apiUrl: 'https://api.openai.com' },
+        { name: 'gemini', model: 'gemini-3-pro', apiUrl: 'https://generativelanguage.googleapis.com' },
+        { name: 'grok', model: 'grok-beta', apiUrl: 'https://api.x.ai' },
+    ];
+    const selectedIndex = parseInt(aiChoice.trim()) - 1 || 0;
+    const selectedProvider = aiProviders[selectedIndex] || aiProviders[0];
+    console.log(`Selected: ${selectedProvider.name} (${selectedProvider.model})`);
+    // 3. API Key - reuse existing if not provided
+    const existingApiKey = existingConfig?.apiKey || '';
+    const hasExistingKey = existingApiKey.length > 0;
+    const keyPrompt = hasExistingKey
+        ? `\nAPI key for ${selectedProvider.name} [press Enter to keep existing]: `
+        : `\nEnter API key for ${selectedProvider.name}: `;
+    const apiKeyInput = await question(keyPrompt);
+    const apiKey = apiKeyInput.trim() || existingApiKey;
+    if (!apiKey) {
+        console.log('Warning: API key not set. You can set it later with config:apiKey=<key>');
+    }
+    else if (apiKeyInput.trim()) {
+        console.log('API key saved');
+    }
+    else {
+        console.log('Using existing API key');
+    }
+    // Save config
+    const config = {
+        aiProvider: selectedProvider.name,
+        apiKey: apiKey,
+        apiUrl: selectedProvider.apiUrl,
+        storagePath: rootDir,
+        currentPath: rootDir,
+        model: selectedProvider.model,
+    };
+    (0, config_1.saveConfig)(config);
+    // Ensure storage directory exists
+    if (!fs.existsSync(rootDir)) {
+        fs.mkdirSync(rootDir, { recursive: true });
+    }
+    console.log('\n╔═══════════════════════════════════════╗');
+    console.log('║         INITIALIZATION COMPLETE       ║');
+    console.log('╚═══════════════════════════════════════╝\n');
+    console.log(`Root directory: ${rootDir}`);
+    console.log(`AI Provider: ${selectedProvider.name}`);
+    console.log(`Model: ${selectedProvider.model}\n`);
+}

package/dist/config/config.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initConfig = initConfig;
+exports.saveConfig = saveConfig;
+exports.getConfig = getConfig;
+exports.updateConfig = updateConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CONFIG_FILE = path.join(os.homedir(), '.rlc', 'config.json');
+const DEFAULT_STORAGE = path.join(os.homedir(), '.rlc', 'notes');
+async function initConfig() {
+    const configDir = path.dirname(CONFIG_FILE);
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    if (!fs.existsSync(CONFIG_FILE)) {
+        return null;
+    }
+    const configData = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    const config = JSON.parse(configData);
+    if (!fs.existsSync(config.storagePath)) {
+        fs.mkdirSync(config.storagePath, { recursive: true });
+    }
+    if (!config.currentPath) {
+        config.currentPath = config.storagePath;
+    }
+    if (!config.model) {
+        config.model = 'claude-sonnet-4-20250514';
+    }
+    return config;
+}
+function saveConfig(config) {
+    const configDir = path.dirname(CONFIG_FILE);
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getConfig() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        throw new Error('Config not initialized. Run rlc first.');
+    }
+    const configData = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    return JSON.parse(configData);
+}
+function updateConfig(updates) {
+    const config = getConfig();
+    const updated = { ...config, ...updates };
+    saveConfig(updated);
+    return updated;
+}

package/dist/index.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const interactive_1 = require("./interactive");
+const config_1 = require("./config/config");
+const init_1 = require("./commands/init");
+async function main() {
+    // Check for "rlc init" command line argument
+    const args = process.argv.slice(2);
+    if (args[0] === 'init') {
+        await (0, init_1.initCommand)();
+        return;
+    }
+    let config = await (0, config_1.initConfig)();
+    if (!config) {
+        console.log('\n╔═══════════════════════════════════════╗');
+        console.log('║     ROGUELIKE CLI NOT INITIALIZED     ║');
+        console.log('╚═══════════════════════════════════════╝\n');
+        console.log('Running init wizard...\n');
+        await (0, init_1.initCommand)();
+        config = await (0, config_1.initConfig)();
+        if (!config) {
+            console.log('Initialization failed. Please try again.');
+            process.exit(1);
+        }
+    }
+    await (0, interactive_1.startInteractive)(config);
+}
+main().catch(console.error);