roguelike-cli 1.0.0

package/dist/utils/schemaParser.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInput = parseInput;
+exports.generateSchema = generateSchema;
+function parseInput(input) {
+    const originalInput = input.trim();
+    let cleanedInput = originalInput;
+    let title = 'Schema';
+    const todoTitleMatch = cleanedInput.match(/^(todo|tasks?)\s+(?:list\s+for\s+)?(.+?)(?:\s*:|\s*$)/i);
+    if (todoTitleMatch) {
+        title = `TODO ${todoTitleMatch[2].trim()}`;
+        cleanedInput = cleanedInput.replace(/^(todo|tasks?)\s+(?:list\s+for\s+)?[^:]+:\s*/i, '');
+    }
+    else {
+        const archTitleMatch = cleanedInput.match(/^(architecture|structure|kubernetes|k8s|yandex|cloud)\s+(?:production\s+)?(.+?)(?:\s*:|\s*$)/i);
+        if (archTitleMatch) {
+            const prefix = archTitleMatch[1].charAt(0).toUpperCase() + archTitleMatch[1].slice(1);
+            title = `${prefix} ${archTitleMatch[2].trim()}`;
+            cleanedInput = cleanedInput.replace(/^(architecture|structure|kubernetes|k8s|yandex|cloud)\s+(?:production\s+)?[^:]+:\s*/i, '');
+        }
+        else {
+            const colonMatch = cleanedInput.match(/^(.+?):\s*(.+)$/);
+            if (colonMatch) {
+                title = colonMatch[1].trim();
+                cleanedInput = colonMatch[2].trim();
+            }
+        }
+    }
+    cleanedInput = cleanedInput.replace(/^(todo|tasks?)\s*:?\s*/i, '');
+    cleanedInput = cleanedInput.replace(/^(architecture|structure)\s*/i, '');
+    cleanedInput = cleanedInput.replace(/^(kubernetes\s+cluster\s+with|kubernetes\s+cluster|kubernetes|k8s)\s*/i, '');
+    cleanedInput = cleanedInput.trim();
+    if (!cleanedInput || cleanedInput.length === 0) {
+        return {
+            title: originalInput || 'Schema',
+            tree: [],
+        };
+    }
+    const parts = cleanedInput.split(',').map(p => p.trim()).filter(p => p.length > 0);
+    const tree = [];
+    const pathMap = {};
+    const branchNodes = {};
+    for (const part of parts) {
+        const metadata = extractMetadata(part);
+        const name = extractNodeName(part);
+        if (part.includes('/')) {
+            const pathParts = part.split('/').map(p => p.trim()).filter(p => p.length > 0);
+            if (pathParts.length > 0) {
+                let currentPath = '';
+                let parentNode = null;
+                pathParts.forEach((pathPart, index) => {
+                    const cleanPart = extractNodeName(pathPart);
+                    const fullPath = currentPath ? `${currentPath}/${cleanPart}` : cleanPart;
+                    if (!pathMap[fullPath]) {
+                        const newNode = {
+                            name: cleanPart,
+                            children: [],
+                        };
+                        if (index === pathParts.length - 1) {
+                            if (metadata.deadline)
+                                newNode.deadline = metadata.deadline;
+                            if (metadata.branch)
+                                newNode.branch = metadata.branch;
+                            if (metadata.zone)
+                                newNode.zone = metadata.zone;
+                        }
+                        pathMap[fullPath] = newNode;
+                        if (parentNode) {
+                            parentNode.children.push(newNode);
+                        }
+                        else {
+                            tree.push(newNode);
+                        }
+                        parentNode = newNode;
+                    }
+                    else {
+                        parentNode = pathMap[fullPath];
+                    }
+                    currentPath = fullPath;
+                });
+            }
+        }
+        else {
+            const newNode = {
+                name,
+                deadline: metadata.deadline,
+                branch: metadata.branch,
+                zone: metadata.zone,
+                children: [],
+            };
+            if (metadata.branch) {
+                if (!branchNodes[metadata.branch]) {
+                    const branchNode = {
+                        name: `Branch: ${metadata.branch}`,
+                        children: [],
+                    };
+                    tree.push(branchNode);
+                    branchNodes[metadata.branch] = branchNode;
+                }
+                branchNodes[metadata.branch].children.push(newNode);
+            }
+            else {
+                tree.push(newNode);
+            }
+        }
+    }
+    return { title, tree };
+}
+function extractNodeName(text) {
+    let cleaned = text.trim();
+    cleaned = cleaned.replace(/\[deadline:\s*[^\]]+\]|deadline:\s*[^\s,]+/gi, '').trim();
+    cleaned = cleaned.replace(/\[branch:\s*[^\]]+\]|branch:\s*[^\s,]+/gi, '').trim();
+    cleaned = cleaned.replace(/\[zone:\s*[^\]]+\]|zone:\s*[^\s,]+/gi, '').trim();
+    cleaned = cleaned.replace(/^\[|\]$/g, '').replace(/,\s*$/, '').trim();
+    return cleaned;
+}
+function extractMetadata(text) {
+    const metadata = {};
+    const deadlineMatch = text.match(/\[deadline:\s*([^\]]+)\]|deadline:\s*([^\s,]+)/i);
+    if (deadlineMatch) {
+        metadata.deadline = (deadlineMatch[1] || deadlineMatch[2]).trim();
+    }
+    const branchMatch = text.match(/\[branch:\s*([^\]]+)\]|branch:\s*([^\s,]+)/i);
+    if (branchMatch) {
+        metadata.branch = (branchMatch[1] || branchMatch[2]).trim();
+    }
+    const zoneMatch = text.match(/\[zone:\s*([^\]]+)\]|zone:\s*([^\s,]+)/i);
+    if (zoneMatch) {
+        metadata.zone = (zoneMatch[1] || zoneMatch[2]).trim();
+    }
+    return metadata;
+}
+function generateSchema(parsed) {
+    if (parsed.tree.length === 0) {
+        return [
+            `┌─ ${parsed.title} ────────────────────┐`,
+            '│ No items                   │',
+            '└────────────────────────────┘',
+        ];
+    }
+    const lines = [];
+    const maxWidth = Math.max(parsed.title.length + 4, calculateMaxWidth(parsed.tree, 0));
+    const width = Math.min(maxWidth + 10, 75);
+    const titlePadding = width - parsed.title.length - 4;
+    lines.push(`┌─ ${parsed.title}${' '.repeat(Math.max(0, titlePadding))}┐`);
+    lines.push(`│${' '.repeat(width - 2)}│`);
+    parsed.tree.forEach((node, index) => {
+        const isLast = index === parsed.tree.length - 1;
+        const nodeLines = generateTreeNode(node, '│ ', isLast, width);
+        lines.push(...nodeLines);
+    });
+    lines.push(`│${' '.repeat(width - 2)}│`);
+    lines.push('└' + '─'.repeat(width - 2) + '┘');
+    return lines;
+}
+function calculateMaxWidth(nodes, depth) {
+    let maxWidth = 20;
+    nodes.forEach(node => {
+        let nodeWidth = node.name.length;
+        if (node.deadline)
+            nodeWidth += node.deadline.length + 3;
+        if (node.branch && !node.name.startsWith('Branch:'))
+            nodeWidth += node.branch.length + 3;
+        if (node.zone && !node.name.startsWith('Zone:'))
+            nodeWidth += node.zone.length + 3;
+        nodeWidth += depth * 4;
+        if (nodeWidth > maxWidth) {
+            maxWidth = nodeWidth;
+        }
+        if (node.children.length > 0) {
+            const childWidth = calculateMaxWidth(node.children, depth + 1);
+            if (childWidth > maxWidth) {
+                maxWidth = childWidth;
+            }
+        }
+    });
+    return maxWidth;
+}
+function generateTreeNode(node, prefix, isLast, width) {
+    const lines = [];
+    let nodeText = node.name;
+    if (node.deadline) {
+        nodeText += ` [${node.deadline}]`;
+    }
+    if (node.branch && !node.name.startsWith('Branch:')) {
+        nodeText += ` (${node.branch})`;
+    }
+    if (node.zone && !node.name.startsWith('Zone:')) {
+        nodeText += ` [zone: ${node.zone}]`;
+    }
+    const connector = isLast ? '└──' : '├──';
+    const spacing = isLast ? '    ' : '│   ';
+    const borderPadding = 2;
+    const prefixLen = prefix.length;
+    const connectorLen = connector.length + 1;
+    const availableWidth = width - prefixLen - connectorLen - borderPadding;
+    let displayText = nodeText;
+    if (displayText.length > availableWidth) {
+        displayText = displayText.substring(0, availableWidth - 3) + '...';
+    }
+    else {
+        displayText = displayText.padEnd(availableWidth);
+    }
+    lines.push(`${prefix}${connector} ${displayText} │`);
+    if (node.children.length > 0) {
+        const childPrefixBase = prefix.replace(/│ $/, spacing);
+        node.children.forEach((child, index) => {
+            const isChildLast = index === node.children.length - 1;
+            const childPrefix = isLast
+                ? childPrefixBase.replace(/│/g, ' ')
+                : childPrefixBase;
+            const childLines = generateTreeNode(child, childPrefix, isChildLast, width);
+            lines.push(...childLines);
+        });
+    }
+    return lines;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "roguelike-cli",
+  "version": "1.0.0",
+  "description": "AI-powered interactive terminal for creating schemas and todo lists",
+  "main": "dist/index.js",
+  "bin": {
+    "rlc": "./bin/rlc"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "todo",
+    "schema",
+    "terminal",
+    "cli",
+    "interactive",
+    "ai",
+    "roguelike"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/creative-ventures/roguelike-cli"
+  },
+  "homepage": "https://www.rlc.rocks",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.20.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "inquirer": "^9.2.12",
+    "ora": "^7.0.1",
+    "readline": "^1.3.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^22.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.0"
+  }
+}
+

package/src/ai/claude.ts

@@ -0,0 +1,139 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { Config } from '../config/config';
+
+export interface GeneratedSchema {
+  title: string;
+  content: string;
+  tree?: any[];
+}
+
+export interface ConversationMessage {
+  role: 'user' | 'assistant';
+  content: string;
+}
+
+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"
+}`;
+
+export async function generateSchemaWithAI(
+  input: string,
+  config: Config,
+  signal?: AbortSignal,
+  history?: ConversationMessage[]
+): Promise<GeneratedSchema | null> {
+  if (!config.apiKey) {
+    throw new Error('API key not set. Use config:apiKey=<key> to set it.');
+  }
+  
+  const client = new Anthropic({
+    apiKey: config.apiKey,
+  });
+  
+  // Build messages from history or just the current input
+  const messages: { role: 'user' | 'assistant'; content: string }[] = [];
+  
+  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: any) {
+    console.error('AI Error:', error.message);
+    return null;
+  }
+}
+

package/src/commands/init.ts

@@ -0,0 +1,159 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { Config, saveConfig, initConfig } from '../config/config';
+
+function question(query: string): Promise<string> {
+  return new Promise((resolve) => {
+    process.stdout.write(query);
+    
+    let input = '';
+    const onData = (chunk: Buffer) => {
+      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: string, dest: string): void {
+  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);
+  }
+}
+
+export async function initCommand(): Promise<void> {
+  console.log('\n╔═══════════════════════════════════════╗');
+  console.log('║   ROGUELIKE CLI INITIALIZATION WIZARD ║');
+  console.log('╚═══════════════════════════════════════╝\n');
+
+  // Get existing config if any
+  const existingConfig = await 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: Config = {
+    aiProvider: selectedProvider.name as any,
+    apiKey: apiKey,
+    apiUrl: selectedProvider.apiUrl,
+    storagePath: rootDir,
+    currentPath: rootDir,
+    model: selectedProvider.model,
+  };
+
+  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/src/config/config.ts

@@ -0,0 +1,69 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export interface Config {
+  aiProvider: 'claude' | 'claude-opus' | 'openai' | 'gemini' | 'grok' | 'custom';
+  apiKey: string;
+  apiUrl?: string;
+  storagePath: string;
+  currentPath: string;
+  model?: string;
+}
+
+const CONFIG_FILE = path.join(os.homedir(), '.rlc', 'config.json');
+const DEFAULT_STORAGE = path.join(os.homedir(), '.rlc', 'notes');
+
+export async function initConfig(): Promise<Config | null> {
+  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: 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;
+}
+
+export function saveConfig(config: Config): void {
+  const configDir = path.dirname(CONFIG_FILE);
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export function getConfig(): Config {
+  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);
+}
+
+export function updateConfig(updates: Partial<Config>): Config {
+  const config = getConfig();
+  const updated = { ...config, ...updates };
+  saveConfig(updated);
+  return updated;
+}
+

package/src/index.ts

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