@nimbus-sh/core 0.1.0

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

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

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

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

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

@@ -0,0 +1,111 @@
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { encode } from '../../utils/encoding.js';
+import { SinkWriter, streamRange } from '../../../../_shared/byte-stream.js';
+const command = async (ctx) => {
+    let lines = 10;
+    let bytes;
+    const files = [];
+    for (let i = 0; i < ctx.args.length; i++) {
+        const arg = ctx.args[i];
+        if (arg === '-n' || arg === '-c') {
+            const count = parseCount(ctx.args[++i]);
+            if (count === null) {
+                ctx.stderr.write(`head: invalid count\n`);
+                return 1;
+            }
+            if (arg === '-c')
+                bytes = count;
+            else
+                lines = count;
+        }
+        else if (/^-[nc]\d/.test(arg)) {
+            const count = parseCount(arg.slice(2));
+            if (count === null) {
+                ctx.stderr.write(`head: invalid count\n`);
+                return 1;
+            }
+            if (arg[1] === 'c')
+                bytes = count;
+            else
+                lines = count;
+        }
+        else if (/^-\d+$/.test(arg)) {
+            lines = Number.parseInt(arg.slice(1), 10);
+        }
+        else {
+            files.push(arg);
+        }
+    }
+    if (files.length === 0) {
+        if (!ctx.stdin) {
+            ctx.stderr.write('head: missing file operand\n');
+            return 1;
+        }
+        if (bytes === undefined) {
+            ctx.stdout.write(headLines(await ctx.stdin.readAll(), lines));
+            return 0;
+        }
+        // -c counts bytes, so pull bounded chunks rather than draining the
+        // producer and slicing characters off the end.
+        const writer = new SinkWriter(ctx.stdout);
+        let copied = 0;
+        while (copied < bytes) {
+            const want = bytes - copied;
+            const chunk = ctx.stdin.readBytes ? await ctx.stdin.readBytes(want) : await ctx.stdin.read();
+            if (chunk === null)
+                break;
+            const encoded = encode(chunk).subarray(0, want);
+            writer.write(encoded);
+            copied += encoded.length;
+        }
+        writer.end();
+        return 0;
+    }
+    let exitCode = 0;
+    const writer = bytes === undefined ? null : new SinkWriter(ctx.stdout);
+    for (const file of files) {
+        const path = resolve(ctx.cwd, file);
+        try {
+            if (files.length > 1)
+                ctx.stdout.write(`==> ${file} <==\n`);
+            if (writer === null) {
+                ctx.stdout.write(headLines(ctx.vfs.readFileString(path), lines));
+            }
+            else {
+                // Bounded read: works on regular files and on endless character
+                // devices alike, since neither is ever materialised whole.
+                streamRange((offset, length) => ctx.vfs.readRange(path, offset, length), writer, {
+                    length: bytes,
+                    signal: ctx.signal,
+                });
+            }
+        }
+        catch (e) {
+            if (e instanceof VFSError) {
+                ctx.stderr.write(`head: ${file}: ${e.message}\n`);
+                exitCode = 1;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    writer?.end();
+    return exitCode;
+};
+function headLines(text, count) {
+    const all = text.split('\n');
+    const selected = all.slice(0, count);
+    return selected.join('\n') + (all.length > count ? '\n' : '');
+}
+function parseCount(value) {
+    if (!value)
+        return null;
+    const match = /^(\d+)([bkKmMgG]?)$/.exec(value);
+    if (!match)
+        return null;
+    const scale = { '': 1, b: 512, k: 1024, K: 1024, m: 1024 ** 2, M: 1024 ** 2, g: 1024 ** 3, G: 1024 ** 3 };
+    return Number.parseInt(match[1], 10) * scale[match[2]];
+}
+export default command;

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

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

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

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

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

@@ -0,0 +1,335 @@
+import { resolve } from '../../utils/path.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+// ─── ANSI ───
+const CSI = '\x1b[';
+const CLEAR = `${CSI}2J`;
+const HOME = `${CSI}H`;
+const HIDE_CURSOR = `${CSI}?25l`;
+const SHOW_CURSOR = `${CSI}?25h`;
+const ERASE_LINE = `${CSI}2K`;
+const INVERT = `${CSI}7m`;
+const BOLD = `${CSI}1m`;
+const RST = `${CSI}0m`;
+function moveTo(row, col) {
+    return `${CSI}${row + 1};${col + 1}H`;
+}
+function parseKey(data) {
+    if (data === '\r')
+        return { type: 'enter' };
+    if (data === '\x7f' || data === '\b')
+        return { type: 'backspace' };
+    if (data === '\x1b' && data.length === 1)
+        return { type: 'escape' };
+    if (data.startsWith('\x1b[')) {
+        const seq = data.slice(2);
+        if (seq === 'A')
+            return { type: 'up' };
+        if (seq === 'B')
+            return { type: 'down' };
+        if (seq === 'C')
+            return { type: 'right' };
+        if (seq === 'D')
+            return { type: 'left' };
+        if (seq === 'H')
+            return { type: 'home' };
+        if (seq === 'F')
+            return { type: 'end' };
+        if (seq === '1~' || seq === '7~')
+            return { type: 'home' };
+        if (seq === '4~' || seq === '8~')
+            return { type: 'end' };
+        if (seq === '5~')
+            return { type: 'pageup' };
+        if (seq === '6~')
+            return { type: 'pagedown' };
+        return { type: 'unknown' };
+    }
+    if (data.length >= 1 && data.charCodeAt(0) >= 32) {
+        return { type: 'char', char: data };
+    }
+    return { type: 'unknown' };
+}
+// ─── Content height (screen minus status bar) ───
+function contentHeight(s) {
+    return s.rows - 1;
+}
+// ─── Search ───
+function findMatches(lines, query) {
+    const matches = [];
+    if (!query)
+        return matches;
+    const lower = query.toLowerCase();
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].toLowerCase().includes(lower))
+            matches.push(i);
+    }
+    return matches;
+}
+function jumpToNextMatch(s) {
+    if (s.searchMatches.length === 0)
+        return;
+    // Find the first match after current scroll position
+    for (let i = 0; i < s.searchMatches.length; i++) {
+        if (s.searchMatches[i] > s.scrollRow) {
+            s.currentMatch = i;
+            s.scrollRow = s.searchMatches[i];
+            return;
+        }
+    }
+    // Wrap to first match
+    s.currentMatch = 0;
+    s.scrollRow = s.searchMatches[0];
+}
+function jumpToPrevMatch(s) {
+    if (s.searchMatches.length === 0)
+        return;
+    for (let i = s.searchMatches.length - 1; i >= 0; i--) {
+        if (s.searchMatches[i] < s.scrollRow) {
+            s.currentMatch = i;
+            s.scrollRow = s.searchMatches[i];
+            return;
+        }
+    }
+    // Wrap to last match
+    s.currentMatch = s.searchMatches.length - 1;
+    s.scrollRow = s.searchMatches[s.currentMatch];
+}
+// ─── Rendering ───
+function render(s, out) {
+    const ch = contentHeight(s);
+    let buf = HIDE_CURSOR;
+    for (let i = 0; i < ch; i++) {
+        const docRow = s.scrollRow + i;
+        buf += moveTo(i, 0) + ERASE_LINE;
+        if (docRow < s.lines.length) {
+            let line = s.lines[docRow].slice(s.scrollCol, s.scrollCol + s.cols);
+            // Highlight search matches
+            if (s.searchQuery && line.toLowerCase().includes(s.searchQuery.toLowerCase())) {
+                line = highlightMatches(line, s.searchQuery);
+            }
+            buf += line;
+        }
+        else {
+            buf += '~';
+        }
+    }
+    // Status bar
+    buf += moveTo(s.rows - 1, 0) + INVERT + ERASE_LINE;
+    if (s.mode === 'search') {
+        buf += '/' + s.searchBuf;
+    }
+    else {
+        const pct = s.lines.length <= ch
+            ? '(END)'
+            : s.scrollRow + ch >= s.lines.length
+                ? '(END)'
+                : `${Math.round(((s.scrollRow + ch) / s.lines.length) * 100)}%`;
+        const matchInfo = s.searchQuery && s.searchMatches.length > 0
+            ? `  [${s.currentMatch + 1}/${s.searchMatches.length}]`
+            : '';
+        const info = `${s.fileName} ${pct}${matchInfo}`;
+        buf += info.padEnd(s.cols);
+    }
+    buf += RST + SHOW_CURSOR;
+    out.write(buf);
+}
+function highlightMatches(line, query) {
+    const lower = line.toLowerCase();
+    const qLower = query.toLowerCase();
+    let result = '';
+    let pos = 0;
+    while (pos < line.length) {
+        const idx = lower.indexOf(qLower, pos);
+        if (idx === -1) {
+            result += line.slice(pos);
+            break;
+        }
+        result += line.slice(pos, idx);
+        result += BOLD + INVERT + line.slice(idx, idx + query.length) + RST;
+        pos = idx + query.length;
+    }
+    return result;
+}
+// ─── Key handlers ───
+function handleViewKey(s, key) {
+    const ch = contentHeight(s);
+    switch (key.type) {
+        case 'char':
+            switch (key.char) {
+                case 'q': return true;
+                case 'j':
+                    s.scrollRow = Math.min(s.scrollRow + 1, maxScroll(s));
+                    break;
+                case 'k':
+                    s.scrollRow = Math.max(s.scrollRow - 1, 0);
+                    break;
+                case 'f':
+                case ' ':
+                    s.scrollRow = Math.min(s.scrollRow + ch, maxScroll(s));
+                    break;
+                case 'b':
+                    s.scrollRow = Math.max(s.scrollRow - ch, 0);
+                    break;
+                case 'd':
+                    s.scrollRow = Math.min(s.scrollRow + Math.floor(ch / 2), maxScroll(s));
+                    break;
+                case 'u':
+                    s.scrollRow = Math.max(s.scrollRow - Math.floor(ch / 2), 0);
+                    break;
+                case 'g':
+                    s.scrollRow = 0;
+                    break;
+                case 'G':
+                    s.scrollRow = maxScroll(s);
+                    break;
+                case '/':
+                    s.mode = 'search';
+                    s.searchBuf = '';
+                    break;
+                case 'n':
+                    jumpToNextMatch(s);
+                    break;
+                case 'N':
+                    jumpToPrevMatch(s);
+                    break;
+                case 'h':
+                    s.scrollCol = Math.max(s.scrollCol - 1, 0);
+                    break;
+                case 'l':
+                    s.scrollCol++;
+                    break;
+            }
+            break;
+        case 'up':
+            s.scrollRow = Math.max(s.scrollRow - 1, 0);
+            break;
+        case 'down':
+            s.scrollRow = Math.min(s.scrollRow + 1, maxScroll(s));
+            break;
+        case 'pageup':
+            s.scrollRow = Math.max(s.scrollRow - ch, 0);
+            break;
+        case 'pagedown':
+            s.scrollRow = Math.min(s.scrollRow + ch, maxScroll(s));
+            break;
+        case 'home':
+            s.scrollRow = 0;
+            break;
+        case 'end':
+            s.scrollRow = maxScroll(s);
+            break;
+        case 'left':
+            s.scrollCol = Math.max(s.scrollCol - 1, 0);
+            break;
+        case 'right':
+            s.scrollCol++;
+            break;
+    }
+    return false;
+}
+function handleSearchKey(s, key) {
+    switch (key.type) {
+        case 'enter':
+            s.searchQuery = s.searchBuf;
+            s.searchMatches = findMatches(s.lines, s.searchQuery);
+            s.currentMatch = -1;
+            s.mode = 'view';
+            if (s.searchMatches.length > 0) {
+                jumpToNextMatch(s);
+            }
+            break;
+        case 'escape':
+            s.mode = 'view';
+            break;
+        case 'backspace':
+            s.searchBuf = s.searchBuf.slice(0, -1);
+            break;
+        case 'char':
+            s.searchBuf += key.char;
+            break;
+    }
+}
+function maxScroll(s) {
+    return Math.max(0, s.lines.length - contentHeight(s));
+}
+// ─── Main command ───
+const command = async (ctx) => {
+    let content;
+    let fileName;
+    if (ctx.args.length > 0) {
+        const path = resolve(ctx.cwd, ctx.args[0]);
+        try {
+            content = ctx.vfs.readFileString(path);
+            fileName = ctx.args[0];
+        }
+        catch (e) {
+            if (e instanceof VFSError) {
+                ctx.stderr.write(`less: ${ctx.args[0]}: ${e.message}\n`);
+                return 1;
+            }
+            throw e;
+        }
+    }
+    else if (ctx.stdin) {
+        content = await ctx.stdin.readAll();
+        fileName = '(stdin)';
+    }
+    else {
+        ctx.stderr.write('Usage: less FILE\n');
+        ctx.stderr.write('View file contents one screen at a time. q to quit, / to search.\n');
+        return 1;
+    }
+    const lines = content.split('\n');
+    if (lines.length > 1 && lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    if (lines.length === 0)
+        lines.push('');
+    const rows = parseInt(ctx.env['LINES'] || '24', 10);
+    const cols = parseInt(ctx.env['COLUMNS'] || '80', 10);
+    // If content fits on screen, just print it and exit (like real less with -F)
+    if (lines.length <= rows - 1) {
+        ctx.stdout.write(content);
+        return 0;
+    }
+    ctx.setRawMode?.(true);
+    try {
+        const s = {
+            lines,
+            scrollRow: 0,
+            scrollCol: 0,
+            rows,
+            cols,
+            fileName,
+            mode: 'view',
+            searchBuf: '',
+            searchQuery: '',
+            searchMatches: [],
+            currentMatch: -1,
+        };
+        ctx.stdout.write(CLEAR + HOME);
+        render(s, ctx.stdout);
+        while (true) {
+            const data = await ctx.stdin?.read();
+            if (data === null || data === undefined)
+                break;
+            const key = parseKey(data);
+            let shouldExit = false;
+            if (s.mode === 'view') {
+                shouldExit = handleViewKey(s, key);
+            }
+            else {
+                handleSearchKey(s, key);
+            }
+            if (shouldExit)
+                break;
+            render(s, ctx.stdout);
+        }
+        ctx.stdout.write(CLEAR + HOME + SHOW_CURSOR);
+    }
+    finally {
+        ctx.setRawMode?.(false);
+    }
+    return 0;
+};
+export default command;

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

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

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

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