roguelike-cli 1.0.0

package/dist/interactive/index.js

@@ -0,0 +1,180 @@
+"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.startInteractive = startInteractive;
+const readline = __importStar(require("readline"));
+const fs = __importStar(require("fs"));
+const startup_1 = require("./startup");
+const commands_1 = require("./commands");
+const config_1 = require("../config/config");
+function getCompletions(currentPath) {
+    if (!fs.existsSync(currentPath)) {
+        return [];
+    }
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    const completions = [];
+    for (const entry of entries) {
+        if (entry.name.startsWith('.'))
+            continue;
+        completions.push(entry.name);
+    }
+    return completions;
+}
+async function startInteractive(initialConfig) {
+    await (0, startup_1.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) => {
+        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 = 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) => {
+        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 (0, commands_1.processCommand)(trimmed, state.currentPath, config, abortController.signal);
+            if (abortController.signal.aborted) {
+                rl.prompt();
+                return;
+            }
+            if (result.reloadConfig) {
+                const newConfig = await (0, config_1.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) {
+            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/dist/interactive/startup.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showStartupAnimation = showStartupAnimation;
+const utils_1 = require("../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...',
+    '',
+];
+async function showStartupAnimation() {
+    for (const line of ASCII_ART) {
+        console.log(line);
+        await (0, utils_1.sleep)(15);
+    }
+    await (0, utils_1.sleep)(100);
+}

package/dist/storage/nodeConfig.js

@@ -0,0 +1,109 @@
+"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.readNodeConfig = readNodeConfig;
+exports.writeNodeConfig = writeNodeConfig;
+exports.createNode = createNode;
+exports.saveSchemaFile = saveSchemaFile;
+exports.readSchemaFile = readSchemaFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const CONFIG_FILE = '.rlc.json';
+function readNodeConfig(nodePath) {
+    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;
+    }
+}
+function writeNodeConfig(nodePath, config) {
+    if (!fs.existsSync(nodePath)) {
+        fs.mkdirSync(nodePath, { recursive: true });
+    }
+    const configPath = path.join(nodePath, CONFIG_FILE);
+    const existing = readNodeConfig(nodePath);
+    const updated = {
+        ...existing,
+        ...config,
+        updatedAt: new Date().toISOString(),
+        createdAt: existing?.createdAt || new Date().toISOString(),
+    };
+    fs.writeFileSync(configPath, JSON.stringify(updated, null, 2), 'utf-8');
+}
+function createNode(parentPath, name, options) {
+    const safeName = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    const nodePath = path.join(parentPath, safeName);
+    const config = {
+        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
+function saveSchemaFile(dirPath, filename, content) {
+    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
+function readSchemaFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    return fs.readFileSync(filePath, 'utf-8');
+}

package/dist/storage/storage.js

@@ -0,0 +1,155 @@
+"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.listSchemas = listSchemas;
+exports.navigateToNode = navigateToNode;
+exports.readSchema = readSchema;
+exports.getTree = getTree;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const nodeConfig_1 = require("./nodeConfig");
+function listSchemas(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        return [];
+    }
+    const items = [];
+    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 = (0, nodeConfig_1.readNodeConfig)(fullPath);
+            items.push({
+                name: entry.name,
+                path: fullPath,
+                config,
+            });
+        }
+    }
+    return items.sort((a, b) => a.name.localeCompare(b.name));
+}
+function navigateToNode(currentPath, nodeName) {
+    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;
+}
+function readSchema(nodePath) {
+    // Read node config and return its info
+    const config = (0, nodeConfig_1.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;
+}
+function getTree(dirPath, prefix = '', isLast = true, maxDepth = 10, currentDepth = 0, showFiles = false) {
+    if (currentDepth >= maxDepth) {
+        return [];
+    }
+    const lines = [];
+    // Get items - either just folders or all entries
+    let items = [];
+    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() ? (0, nodeConfig_1.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/dist/utils/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = sleep;
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}