@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/commands/text/sed.js

@@ -0,0 +1,248 @@
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { getMimeType, isBinaryMime } from '../../utils/mime.js';
+function parseSedExpr(expr) {
+    if (expr === 'd') {
+        return { type: 'd' };
+    }
+    if (expr === 'p') {
+        return { type: 'p' };
+    }
+    // s/pattern/replacement/flags
+    if (expr.startsWith('s')) {
+        const delim = expr[1];
+        if (!delim)
+            return null;
+        const parts = [];
+        let current = '';
+        let escaped = false;
+        for (let i = 2; i < expr.length; i++) {
+            if (escaped) {
+                current += expr[i];
+                escaped = false;
+            }
+            else if (expr[i] === '\\') {
+                escaped = true;
+                current += '\\';
+            }
+            else if (expr[i] === delim) {
+                parts.push(current);
+                current = '';
+            }
+            else {
+                current += expr[i];
+            }
+        }
+        parts.push(current); // remaining flags part
+        if (parts.length < 2)
+            return null;
+        const patternStr = parts[0];
+        const replacement = parts[1] ?? '';
+        const flagStr = parts[2] || '';
+        const globalFlag = flagStr.includes('g');
+        const caseInsensitive = flagStr.includes('i');
+        const print = flagStr.includes('p');
+        let regex;
+        try {
+            let flags = '';
+            if (globalFlag)
+                flags += 'g';
+            if (caseInsensitive)
+                flags += 'i';
+            regex = new RegExp(toJavascriptPattern(patternStr ?? ''), flags);
+        }
+        catch {
+            return null;
+        }
+        return { type: 's', pattern: regex, replacement, global: globalFlag, print };
+    }
+    return null;
+}
+function toJavascriptPattern(pattern) {
+    let result = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        const next = pattern[i + 1];
+        if (char === '\\' && (next === '(' || next === ')')) {
+            result += next;
+            i++;
+            continue;
+        }
+        result += char;
+    }
+    return result;
+}
+function isDigit(value) {
+    const code = value.charCodeAt(0);
+    return code >= 48 && code <= 57;
+}
+export async function runSed(ctx) {
+    const options = parseSedArgs(ctx.args);
+    if (options.expressions.length === 0) {
+        ctx.stderr.write('sed: missing expression\n');
+        return 1;
+    }
+    const parsedExprs = [];
+    for (const expr of options.expressions) {
+        const parsed = parseSedExpr(expr);
+        if (!parsed) {
+            ctx.stderr.write(`sed: invalid expression: ${expr}\n`);
+            return 1;
+        }
+        parsedExprs.push(parsed);
+    }
+    function processText(text) {
+        const lines = text.replace(/\n$/, '').split('\n');
+        const output = [];
+        for (let line of lines) {
+            let deleted = false;
+            for (const expr of parsedExprs) {
+                if (expr.type === 's' && expr.pattern && expr.replacement !== undefined) {
+                    let changed = false;
+                    expr.pattern.lastIndex = 0;
+                    line = line.replace(expr.pattern, (...match) => {
+                        changed = true;
+                        return expandReplacement(expr.replacement ?? '', match.slice(1, -2), String(match[0]));
+                    });
+                    if (changed && expr.print) {
+                        output.push(line);
+                    }
+                }
+                else if (expr.type === 'd') {
+                    deleted = true;
+                    break;
+                }
+                else if (expr.type === 'p') {
+                    output.push(line);
+                }
+            }
+            if (!deleted && !options.quiet) {
+                output.push(line);
+            }
+        }
+        return output.join('\n') + '\n';
+    }
+    if (options.files.length === 0) {
+        if (ctx.stdin) {
+            const text = await ctx.stdin.readAll();
+            ctx.stdout.write(processText(text));
+        }
+        else {
+            ctx.stderr.write('sed: missing file operand\n');
+            return 1;
+        }
+        return 0;
+    }
+    let exitCode = 0;
+    for (const file of options.files) {
+        const path = resolve(ctx.cwd, file);
+        try {
+            ctx.vfs.stat(path);
+            if (isBinaryMime(getMimeType(path))) {
+                ctx.stderr.write(`sed: ${file}: binary file, skipping\n`);
+                continue;
+            }
+            const content = ctx.vfs.readFileString(path);
+            const result = processText(content);
+            if (options.inPlace) {
+                ctx.vfs.writeFile(path, result);
+            }
+            else {
+                ctx.stdout.write(result);
+            }
+        }
+        catch (e) {
+            if (e instanceof VFSError) {
+                ctx.stderr.write(`sed: ${file}: ${e.message}\n`);
+                exitCode = 1;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    return exitCode;
+}
+function parseSedArgs(args) {
+    const options = {
+        inPlace: false,
+        quiet: false,
+        expressions: [],
+        files: [],
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i] ?? '';
+        if (arg === '-i') {
+            options.inPlace = true;
+            continue;
+        }
+        if (arg === '-n' || arg === '--quiet' || arg === '--silent') {
+            options.quiet = true;
+            continue;
+        }
+        if (arg === '-e') {
+            options.expressions.push(args[++i] ?? '');
+            continue;
+        }
+        if (arg.startsWith('-') && arg.length > 2 && parseSedShortCluster(options, arg, args, i)) {
+            if (clusterNeedsNextArg(arg))
+                i++;
+            continue;
+        }
+        if (options.expressions.length === 0 && !arg.startsWith('-')) {
+            options.expressions.push(arg);
+            continue;
+        }
+        options.files.push(arg);
+    }
+    return options;
+}
+function parseSedShortCluster(options, arg, args, index) {
+    for (let j = 1; j < arg.length; j++) {
+        const flag = arg[j];
+        if (flag === 'n') {
+            options.quiet = true;
+            continue;
+        }
+        if (flag === 'i') {
+            options.inPlace = true;
+            continue;
+        }
+        if (flag === 'e') {
+            const rest = arg.slice(j + 1);
+            options.expressions.push(rest || args[index + 1] || '');
+            return true;
+        }
+        return false;
+    }
+    return true;
+}
+function clusterNeedsNextArg(arg) {
+    const eIndex = arg.indexOf('e');
+    return eIndex !== -1 && eIndex === arg.length - 1;
+}
+function expandReplacement(replacement, captures, matched) {
+    let result = '';
+    for (let i = 0; i < replacement.length; i++) {
+        const char = replacement[i];
+        const next = replacement[i + 1];
+        if (char === '\\' && next !== undefined) {
+            if (isDigit(next)) {
+                result += String(captures[Number(next) - 1] ?? '');
+                i++;
+                continue;
+            }
+            result += next;
+            i++;
+            continue;
+        }
+        if (char === '&') {
+            result += matched;
+            continue;
+        }
+        result += char;
+    }
+    return result;
+}
+const command = async (ctx) => runSed(ctx);
+export default command;

package/dist/substrate/lifo/commands/text/seq.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=seq.d.ts.map

package/dist/substrate/lifo/commands/text/seq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seq.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/text/seq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,QAAA,MAAM,OAAO,EAAE,OAuEd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/text/seq.js

@@ -0,0 +1,69 @@
+const command = async (ctx) => {
+    const args = ctx.args;
+    if (args.length === 0) {
+        ctx.stderr.write('Usage: seq [-s SEP] [FIRST [INCR]] LAST\n');
+        ctx.stderr.write('Print a sequence of numbers.\n');
+        return 1;
+    }
+    let first = 1;
+    let increment = 1;
+    let last;
+    let separator = '\n';
+    let equalWidth = false;
+    // Parse -s / -w options
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '-s' && i + 1 < args.length) {
+            separator = args[++i];
+        }
+        else if (args[i] === '-w') {
+            equalWidth = true;
+        }
+        else {
+            positional.push(args[i]);
+        }
+    }
+    if (positional.length === 1) {
+        last = parseFloat(positional[0]);
+    }
+    else if (positional.length === 2) {
+        first = parseFloat(positional[0]);
+        last = parseFloat(positional[1]);
+    }
+    else {
+        first = parseFloat(positional[0]);
+        increment = parseFloat(positional[1]);
+        last = parseFloat(positional[2]);
+    }
+    if (isNaN(first) || isNaN(increment) || isNaN(last)) {
+        ctx.stderr.write('seq: invalid argument\n');
+        return 1;
+    }
+    if (increment === 0) {
+        ctx.stderr.write('seq: zero increment\n');
+        return 1;
+    }
+    const results = [];
+    const isInt = Number.isInteger(first) && Number.isInteger(increment) && Number.isInteger(last);
+    if (increment > 0) {
+        for (let n = first; n <= last + 1e-10; n += increment) {
+            results.push(isInt ? String(Math.round(n)) : String(n));
+        }
+    }
+    else {
+        for (let n = first; n >= last - 1e-10; n += increment) {
+            results.push(isInt ? String(Math.round(n)) : String(n));
+        }
+    }
+    if (results.length > 0) {
+        if (equalWidth && isInt) {
+            const maxLen = Math.max(...results.map(r => r.length));
+            ctx.stdout.write(results.map(r => r.padStart(maxLen, '0')).join(separator) + '\n');
+        }
+        else {
+            ctx.stdout.write(results.join(separator) + '\n');
+        }
+    }
+    return 0;
+};
+export default command;

package/dist/substrate/lifo/commands/text/sort.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=sort.d.ts.map

package/dist/substrate/lifo/commands/text/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/text/sort.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAK3C,QAAA,MAAM,OAAO,EAAE,OAgFd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/text/sort.js

@@ -0,0 +1,90 @@
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { getMimeType, isBinaryMime } from '../../utils/mime.js';
+const command = async (ctx) => {
+    let reverse = false;
+    let numeric = false;
+    let unique = false;
+    let keyField = 0; // 0 = whole line, 1-based field index
+    const files = [];
+    for (let i = 0; i < ctx.args.length; i++) {
+        const arg = ctx.args[i];
+        if (arg === '-k' && i + 1 < ctx.args.length) {
+            keyField = parseInt(ctx.args[++i], 10);
+        }
+        else if (arg.startsWith('-') && arg.length > 1) {
+            for (let j = 1; j < arg.length; j++) {
+                switch (arg[j]) {
+                    case 'r':
+                        reverse = true;
+                        break;
+                    case 'n':
+                        numeric = true;
+                        break;
+                    case 'u':
+                        unique = true;
+                        break;
+                }
+            }
+        }
+        else {
+            files.push(arg);
+        }
+    }
+    let text = '';
+    if (files.length === 0) {
+        if (ctx.stdin) {
+            text = await ctx.stdin.readAll();
+        }
+        else {
+            ctx.stderr.write('sort: missing file operand\n');
+            return 1;
+        }
+    }
+    else {
+        for (const file of files) {
+            const path = resolve(ctx.cwd, file);
+            try {
+                ctx.vfs.stat(path);
+                if (isBinaryMime(getMimeType(path))) {
+                    ctx.stderr.write(`sort: ${file}: binary file, skipping\n`);
+                    continue;
+                }
+                text += ctx.vfs.readFileString(path);
+            }
+            catch (e) {
+                if (e instanceof VFSError) {
+                    ctx.stderr.write(`sort: ${file}: ${e.message}\n`);
+                    return 1;
+                }
+                throw e;
+            }
+        }
+    }
+    let lines = text.replace(/\n$/, '').split('\n');
+    function getKey(line) {
+        if (keyField > 0) {
+            const fields = line.split(/\s+/);
+            return fields[keyField - 1] || '';
+        }
+        return line;
+    }
+    lines.sort((a, b) => {
+        const ka = getKey(a);
+        const kb = getKey(b);
+        let cmp;
+        if (numeric) {
+            cmp = (parseFloat(ka) || 0) - (parseFloat(kb) || 0);
+        }
+        else {
+            cmp = ka.localeCompare(kb);
+        }
+        return reverse ? -cmp : cmp;
+    });
+    if (unique) {
+        lines = lines.filter((line, idx) => idx === 0 || line !== lines[idx - 1]);
+    }
+    ctx.stdout.write(lines.join('\n') + '\n');
+    return 0;
+};
+export default command;

package/dist/substrate/lifo/commands/text/strings.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=strings.d.ts.map

package/dist/substrate/lifo/commands/text/strings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/text/strings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AA2B3C,QAAA,MAAM,OAAO,EAAE,OA2Cd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/text/strings.js

@@ -0,0 +1,69 @@
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+function extractStrings(data, minLen) {
+    const results = [];
+    let current = '';
+    for (let i = 0; i < data.length; i++) {
+        const byte = data[i];
+        // Printable ASCII range (space through tilde) plus tab
+        if ((byte >= 0x20 && byte <= 0x7e) || byte === 0x09) {
+            current += String.fromCharCode(byte);
+        }
+        else {
+            if (current.length >= minLen) {
+                results.push(current);
+            }
+            current = '';
+        }
+    }
+    if (current.length >= minLen) {
+        results.push(current);
+    }
+    return results;
+}
+const command = async (ctx) => {
+    let minLen = 4;
+    const files = [];
+    for (let i = 0; i < ctx.args.length; i++) {
+        const arg = ctx.args[i];
+        if (arg === '-n' && i + 1 < ctx.args.length) {
+            minLen = parseInt(ctx.args[++i], 10);
+            if (isNaN(minLen) || minLen < 1)
+                minLen = 4;
+        }
+        else if (arg.startsWith('-') && arg.length > 1 && !isNaN(parseInt(arg.slice(1), 10))) {
+            minLen = parseInt(arg.slice(1), 10);
+            if (minLen < 1)
+                minLen = 4;
+        }
+        else {
+            files.push(arg);
+        }
+    }
+    let exitCode = 0;
+    if (files.length === 0) {
+        ctx.stderr.write('Usage: strings [-n MIN] FILE...\n');
+        ctx.stderr.write('Print sequences of printable characters from files.\n');
+        return 1;
+    }
+    for (const file of files) {
+        const path = resolve(ctx.cwd, file);
+        try {
+            const data = ctx.vfs.readFile(path);
+            for (const s of extractStrings(data, minLen)) {
+                ctx.stdout.write(s + '\n');
+            }
+        }
+        catch (e) {
+            if (e instanceof VFSError) {
+                ctx.stderr.write(`strings: ${file}: ${e.message}\n`);
+                exitCode = 1;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    return exitCode;
+};
+export default command;

package/dist/substrate/lifo/commands/text/tac.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=tac.d.ts.map

package/dist/substrate/lifo/commands/text/tac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tac.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/text/tac.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAI3C,QAAA,MAAM,OAAO,EAAE,OA8Bd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/text/tac.js

@@ -0,0 +1,32 @@
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+const command = async (ctx) => {
+    let exitCode = 0;
+    const processContent = (content) => {
+        const lines = content.replace(/\n$/, '').split('\n');
+        lines.reverse();
+        ctx.stdout.write(lines.join('\n') + '\n');
+    };
+    if (ctx.args.length === 0) {
+        ctx.stderr.write('Usage: tac FILE...\n');
+        ctx.stderr.write('Print files in reverse line order.\n');
+        return 1;
+    }
+    for (const arg of ctx.args) {
+        const path = resolve(ctx.cwd, arg);
+        try {
+            processContent(ctx.vfs.readFileString(path));
+        }
+        catch (e) {
+            if (e instanceof VFSError) {
+                ctx.stderr.write(`tac: ${arg}: ${e.message}\n`);
+                exitCode = 1;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    return exitCode;
+};
+export default command;

package/dist/substrate/lifo/commands/text/tail.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=tail.d.ts.map

package/dist/substrate/lifo/commands/text/tail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tail.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/text/tail.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAK3C,QAAA,MAAM,OAAO,EAAE,OAuDd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/substrate/lifo/commands/text/tail.js

@@ -0,0 +1,64 @@
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { getMimeType, isBinaryMime } from '../../utils/mime.js';
+const command = async (ctx) => {
+    let count = 10;
+    const files = [];
+    for (let i = 0; i < ctx.args.length; i++) {
+        const arg = ctx.args[i];
+        if (arg === '-n' && i + 1 < ctx.args.length) {
+            count = parseInt(ctx.args[++i], 10);
+            if (isNaN(count)) {
+                ctx.stderr.write('tail: invalid number of lines\n');
+                return 1;
+            }
+        }
+        else if (/^-\d+$/.test(arg)) {
+            count = parseInt(arg.slice(1), 10);
+        }
+        else {
+            files.push(arg);
+        }
+    }
+    async function tailText(text) {
+        const lines = text.replace(/\n$/, '').split('\n');
+        const selected = lines.slice(-count);
+        ctx.stdout.write(selected.join('\n') + '\n');
+    }
+    if (files.length === 0) {
+        if (ctx.stdin) {
+            await tailText(await ctx.stdin.readAll());
+        }
+        else {
+            ctx.stderr.write('tail: missing file operand\n');
+            return 1;
+        }
+        return 0;
+    }
+    let exitCode = 0;
+    for (const file of files) {
+        const path = resolve(ctx.cwd, file);
+        try {
+            ctx.vfs.stat(path);
+            if (isBinaryMime(getMimeType(path))) {
+                ctx.stderr.write(`tail: ${file}: binary file, skipping\n`);
+                continue;
+            }
+            const content = ctx.vfs.readFileString(path);
+            if (files.length > 1)
+                ctx.stdout.write(`==> ${file} <==\n`);
+            await tailText(content);
+        }
+        catch (e) {
+            if (e instanceof VFSError) {
+                ctx.stderr.write(`tail: ${file}: ${e.message}\n`);
+                exitCode = 1;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    return exitCode;
+};
+export default command;

package/dist/substrate/lifo/commands/text/tr.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from '../types.js';
+declare const command: Command;
+export default command;
+//# sourceMappingURL=tr.d.ts.map

package/dist/substrate/lifo/commands/text/tr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tr.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/commands/text/tr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAgG3C,QAAA,MAAM,OAAO,EAAE,OA6Fd,CAAC;AAEF,eAAe,OAAO,CAAC"}