roguelike-cli 1.0.0

package/src/interactive/index.ts

@@ -0,0 +1,174 @@
+import * as readline from 'readline';
+import * as fs from 'fs';
+import * as path from 'path';
+import { showStartupAnimation } from './startup';
+import { processCommand } from './commands';
+import { Config, initConfig } from '../config/config';
+
+function getCompletions(currentPath: string): string[] {
+  if (!fs.existsSync(currentPath)) {
+    return [];
+  }
+  
+  const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+  const completions: string[] = [];
+  
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) continue;
+    
+    completions.push(entry.name);
+  }
+  
+  return completions;
+}
+
+export async function startInteractive(initialConfig: Config): Promise<void> {
+  await showStartupAnimation();
+  
+  let config = initialConfig;
+  
+  // Use object to hold currentPath so closures always get the current value
+  const state = {
+    currentPath: config.currentPath
+  };
+  
+  // Completer function that uses state.currentPath
+  const completer = (line: string): [string[], string] => {
+    try {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        return [[], ''];
+      }
+      
+      // Find the last word using regex to get exact position
+      const lastWordMatch = line.match(/(\S+)$/);
+      if (!lastWordMatch) {
+        return [[], line];
+      }
+      
+      const lastWord = lastWordMatch[1];
+      const lastWordStart = lastWordMatch.index!;
+      const prefix = line.substring(lastWordStart);
+      
+      const parts = trimmed.split(/\s+/);
+      const command = parts[0]?.toLowerCase() || '';
+      
+      // Only autocomplete if we're in a command that takes a path argument
+      const commandsThatNeedCompletion = ['cd', 'open', 'cp', 'rm', 'mkdir'];
+      
+      if (commandsThatNeedCompletion.includes(command) && parts.length > 1) {
+        const completions = getCompletions(state.currentPath);
+        const hits = completions.filter((c) => c.toLowerCase().startsWith(lastWord.toLowerCase()));
+        
+        return [hits.length > 0 ? hits : [], prefix];
+      }
+      
+      // If we're typing a command name itself
+      if (parts.length === 1) {
+        const commandCompletions = ['ls', 'cd', 'mkdir', 'open', 'cp', 'rm', 'tree', 'pwd', 'init', 'config', 'help', 'save', 'cancel', 'clean', 'exit', 'quit', '..', '...'];
+        const hits = commandCompletions.filter((c) => c.toLowerCase().startsWith(lastWord.toLowerCase()));
+        return [hits.length > 0 ? hits : commandCompletions, prefix];
+      }
+      
+      return [[], line];
+    } catch (e) {
+      // Return empty completion on any error to prevent crash
+      return [[], line];
+    }
+  };
+  
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '> ',
+    completer: completer,
+  });
+  
+  let isProcessingCommand = false;
+  let currentCommandAbortController: AbortController | null = null;
+  
+  // Override SIGINT to cancel commands instead of exiting
+  process.on('SIGINT', () => {
+    if (isProcessingCommand) {
+      // Cancel current command but stay in program
+      if (currentCommandAbortController) {
+        currentCommandAbortController.abort();
+        currentCommandAbortController = null;
+      }
+      isProcessingCommand = false;
+      console.log('\n^C');
+      rl.prompt();
+    } else {
+      // Clear the line if not processing
+      rl.write('\x1B[2K\r> ');
+    }
+  });
+  
+  rl.on('line', async (input: string) => {
+    const trimmed = input.trim();
+    
+    if (trimmed === 'exit' || trimmed === 'quit') {
+      rl.close();
+      return;
+    }
+    
+    if (trimmed === '') {
+      rl.prompt();
+      return;
+    }
+    
+    // Create abort controller for this command
+    currentCommandAbortController = new AbortController();
+    isProcessingCommand = true;
+    
+    const abortController = currentCommandAbortController;
+    
+    try {
+      const result = await processCommand(trimmed, state.currentPath, config, abortController.signal);
+      
+      if (abortController.signal.aborted) {
+        rl.prompt();
+        return;
+      }
+      
+      if (result.reloadConfig) {
+        const newConfig = await initConfig();
+        if (newConfig) {
+          config = newConfig;
+          state.currentPath = config.currentPath;
+        }
+      }
+      
+      if (result.newPath) {
+        state.currentPath = result.newPath;
+      }
+      
+      if (result.output) {
+        console.log(result.output);
+      }
+    } catch (error: any) {
+      if (error.name === 'AbortError' || abortController.signal.aborted) {
+        console.log('\nCommand cancelled.');
+      } else {
+        console.error(`Error: ${error.message}`);
+      }
+    } finally {
+      isProcessingCommand = false;
+      currentCommandAbortController = null;
+    }
+    
+    rl.prompt();
+  });
+  
+  rl.on('close', () => {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    console.log('\nGoodbye!');
+    process.exit(0);
+  });
+  
+  rl.prompt();
+}
+
+

package/src/interactive/startup.ts

@@ -0,0 +1,38 @@
+import { sleep } from '../utils';
+
+const ASCII_ART = [
+  '',
+  '  |',
+  '  |',
+  '  + \\',
+  '  \\.G_.*=.',
+  '   `(#\'/.\|',
+  '    .>\' (_--.',
+  ' _=/d   ,^\\',
+  '~~ \\)-\'   \'',
+  '   / |',
+  '  \'  \'',
+  '',
+  '╔═════════════════════════╗',
+  '║    Roguelike CLI v1.0   ║',
+  '║     www.rlc.rocks       ║',
+  '╚═════════════════════════╝',
+  '',
+  '  Commands: ls, cd, mkdir, open, cp, mv, rm, tree, pwd, clean',
+  '  TAB to autocomplete, | pbcopy to copy output',
+  '',
+  '  Workflow: <description> -> refine -> save',
+  '  init - setup, config - settings, help - examples',
+  '',
+  '  Ready...',
+  '',
+];
+
+export async function showStartupAnimation(): Promise<void> {
+  for (const line of ASCII_ART) {
+    console.log(line);
+    await sleep(15);
+  }
+  await sleep(100);
+}
+

package/src/storage/nodeConfig.ts

@@ -0,0 +1,109 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface NodeConfig {
+  name: string;
+  deadline?: string;
+  branch?: string;
+  zone?: string;
+  description?: string;
+  createdAt: string;
+  updatedAt: string;
+  metadata?: Record<string, any>;
+}
+
+const CONFIG_FILE = '.rlc.json';
+
+export function readNodeConfig(nodePath: string): NodeConfig | null {
+  const configPath = path.join(nodePath, CONFIG_FILE);
+  
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  
+  try {
+    const data = fs.readFileSync(configPath, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+export function writeNodeConfig(nodePath: string, config: NodeConfig): void {
+  if (!fs.existsSync(nodePath)) {
+    fs.mkdirSync(nodePath, { recursive: true });
+  }
+  
+  const configPath = path.join(nodePath, CONFIG_FILE);
+  const existing = readNodeConfig(nodePath);
+  
+  const updated: NodeConfig = {
+    ...existing,
+    ...config,
+    updatedAt: new Date().toISOString(),
+    createdAt: existing?.createdAt || new Date().toISOString(),
+  };
+  
+  fs.writeFileSync(configPath, JSON.stringify(updated, null, 2), 'utf-8');
+}
+
+export function createNode(
+  parentPath: string,
+  name: string,
+  options?: {
+    deadline?: string;
+    branch?: string;
+    zone?: string;
+    description?: string;
+    metadata?: Record<string, any>;
+  }
+): string {
+  const safeName = name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  
+  const nodePath = path.join(parentPath, safeName);
+  
+  const config: NodeConfig = {
+    name,
+    deadline: options?.deadline,
+    branch: options?.branch,
+    zone: options?.zone,
+    description: options?.description,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    metadata: options?.metadata,
+  };
+  
+  writeNodeConfig(nodePath, config);
+  
+  return nodePath;
+}
+
+// Save schema content to .rlc.schema file
+export function saveSchemaFile(dirPath: string, filename: string, content: string): string {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+  
+  const safeName = filename
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  
+  const schemaPath = path.join(dirPath, `${safeName}.rlc.schema`);
+  fs.writeFileSync(schemaPath, content, 'utf-8');
+  
+  return schemaPath;
+}
+
+// Read schema file
+export function readSchemaFile(filePath: string): string | null {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  
+  return fs.readFileSync(filePath, 'utf-8');
+}
+

package/src/storage/storage.ts

@@ -0,0 +1,143 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { readNodeConfig, NodeConfig } from './nodeConfig';
+
+export interface SchemaInfo {
+  name: string;
+  path: string;
+  config?: NodeConfig | null;
+}
+
+export function listSchemas(dirPath: string): SchemaInfo[] {
+  if (!fs.existsSync(dirPath)) {
+    return [];
+  }
+  
+  const items: SchemaInfo[] = [];
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    
+    // Skip hidden files
+    if (entry.name.startsWith('.')) {
+      continue;
+    }
+    
+    if (entry.isDirectory()) {
+      const config = readNodeConfig(fullPath);
+      items.push({
+        name: entry.name,
+        path: fullPath,
+        config,
+      });
+    }
+  }
+  
+  return items.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function navigateToNode(currentPath: string, nodeName: string): string | null {
+  const schemas = listSchemas(currentPath);
+  const node = schemas.find(s => s.name.toLowerCase() === nodeName.toLowerCase());
+  
+  if (!node) {
+    return null;
+  }
+  
+  if (fs.statSync(node.path).isDirectory()) {
+    return node.path;
+  }
+  
+  return node.path;
+}
+
+export function readSchema(nodePath: string): string | null {
+  // Read node config and return its info
+  const config = readNodeConfig(nodePath);
+  
+  if (!config) {
+    return null;
+  }
+  
+  let output = `${config.name}`;
+  if (config.deadline) output += `\nDeadline: ${config.deadline}`;
+  if (config.branch) output += `\nBranch: ${config.branch}`;
+  if (config.zone) output += `\nZone: ${config.zone}`;
+  if (config.description) output += `\n${config.description}`;
+  
+  return output;
+}
+
+export function getTree(dirPath: string, prefix = '', isLast = true, maxDepth = 10, currentDepth = 0, showFiles = false): string[] {
+  if (currentDepth >= maxDepth) {
+    return [];
+  }
+  
+  const lines: string[] = [];
+  
+  // Get items - either just folders or all entries
+  let items: { name: string; path: string; isDir: boolean; config?: any }[] = [];
+  
+  if (showFiles) {
+    // Show all files and folders
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+      
+      const fullPath = path.join(dirPath, entry.name);
+      const config = entry.isDirectory() ? readNodeConfig(fullPath) : null;
+      
+      items.push({
+        name: entry.name,
+        path: fullPath,
+        isDir: entry.isDirectory(),
+        config
+      });
+    }
+    // Sort: folders first, then files
+    items.sort((a, b) => {
+      if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+  } else {
+    // Only folders (original behavior)
+    const schemas = listSchemas(dirPath);
+    items = schemas.map(s => ({
+      name: s.name,
+      path: s.path,
+      isDir: true,
+      config: s.config
+    }));
+  }
+  
+  items.forEach((item, index) => {
+    const isItemLast = index === items.length - 1;
+    const connector = isItemLast ? '└──' : '├──';
+    const currentPrefix = prefix + (isLast ? '    ' : '│   ');
+    
+    let displayName = item.name;
+    
+    // Add file indicator
+    if (!item.isDir) {
+      displayName = `* ${displayName}`;
+    }
+    
+    if (item.config?.deadline) {
+      displayName += ` [${item.config.deadline}]`;
+    }
+    if (item.config?.branch) {
+      displayName += ` (${item.config.branch})`;
+    }
+    
+    lines.push(`${prefix}${connector} ${displayName}`);
+    
+    if (item.isDir) {
+      const childLines = getTree(item.path, currentPrefix, isItemLast, maxDepth, currentDepth + 1, showFiles);
+      lines.push(...childLines);
+    }
+  });
+  
+  return lines;
+}
+

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+