terminal-quest 1.0.0

package/dist/engine/commands/head.js

@@ -0,0 +1,59 @@
+export function head(fs, args) {
+    // Extract stdin
+    let stdin;
+    const stdinIdx = args.findIndex(a => a.startsWith('__stdin__:'));
+    if (stdinIdx !== -1) {
+        stdin = args[stdinIdx].slice('__stdin__:'.length);
+        args = [...args.slice(0, stdinIdx), ...args.slice(stdinIdx + 1)];
+    }
+    let lineCount = 10;
+    const files = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '-n') {
+            i++;
+            if (i >= args.length) {
+                return { output: '', error: 'head: option requires an argument -- n' };
+            }
+            const n = parseInt(args[i], 10);
+            if (isNaN(n)) {
+                return { output: '', error: `head: invalid number of lines: '${args[i]}'` };
+            }
+            lineCount = n;
+        }
+        else if (arg.startsWith('-n')) {
+            const n = parseInt(arg.slice(2), 10);
+            if (isNaN(n)) {
+                return { output: '', error: `head: invalid number of lines: '${arg.slice(2)}'` };
+            }
+            lineCount = n;
+        }
+        else if (arg.startsWith('-')) {
+            return { output: '', error: `head: invalid option -- '${arg}'` };
+        }
+        else {
+            files.push(arg);
+        }
+    }
+    let content;
+    if (files.length > 0) {
+        try {
+            content = fs.readFile(files[0]);
+        }
+        catch (e) {
+            return { output: '', error: `head: ${e.message}` };
+        }
+    }
+    else if (stdin !== undefined) {
+        content = stdin;
+    }
+    else {
+        return { output: '', error: 'head: missing file operand' };
+    }
+    if (content === '')
+        return { output: '' };
+    const lines = content.split('\n');
+    const selected = lines.slice(0, lineCount);
+    return { output: selected.join('\n') };
+}
+//# sourceMappingURL=head.js.map

package/dist/engine/commands/help.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function help(_fs: VirtualFS, _args: string[]): CommandResult;
+//# sourceMappingURL=help.d.ts.map

package/dist/engine/commands/help.js

@@ -0,0 +1,32 @@
+const HELP_TEXT = `使用可能なコマンド:
+  pwd                          現在のディレクトリを表示
+  ls [path]                    ファイル一覧 (-l 詳細, -a 全表示)
+  cd [path]                    ディレクトリ移動
+  cat file...                  ファイル内容を表示
+  grep [opts] pattern file     パターン検索 (-i, -n, -r)
+  cp [-r] src dest             コピー
+  mv src dest                  移動・名前変更
+  mkdir [-p] path              ディレクトリ作成
+  rm [-r] [-f] path            削除
+  touch file                   空ファイル作成
+  find [path] [-name p] [-type t]  ファイル検索
+  head [-n N] file             先頭N行を表示
+  tail [-n N] file             末尾N行を表示
+  wc [-l] [-w] [-c] file       行数/単語数/バイト数
+  sort [-r] [-n] file          ソート
+  uniq [-c] file               重複除去
+  cut -d delim -f N file       フィールド切り出し
+  chmod mode file              権限変更
+  echo text [> file]           テキスト出力/ファイル書き込み
+  git <subcmd>                 Gitコマンド (status/log/diff/branch/checkout/merge/stash)
+  clear                        画面クリア
+  help                         このヘルプを表示
+  hint                         ヒントを表示
+  objectives / obj             現在の目標を表示
+
+  ヒント: コマンドは | (パイプ) で繋げられます
+  例: cat file.txt | grep ERROR | wc -l`;
+export function help(_fs, _args) {
+    return { output: HELP_TEXT };
+}
+//# sourceMappingURL=help.js.map

package/dist/engine/commands/hint.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function hint(_fs: VirtualFS, _args: string[]): CommandResult;
+//# sourceMappingURL=hint.d.ts.map

package/dist/engine/commands/hint.js

@@ -0,0 +1,4 @@
+export function hint(_fs, _args) {
+    return { output: 'HINT_REQUEST' };
+}
+//# sourceMappingURL=hint.js.map

package/dist/engine/commands/index.d.ts

@@ -0,0 +1,8 @@
+import { VirtualFS } from '../VirtualFS.js';
+export interface CommandResult {
+    output: string;
+    error?: string;
+}
+export type CommandFn = (fs: VirtualFS, args: string[]) => CommandResult;
+export declare const commandRegistry: Record<string, CommandFn>;
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/commands/index.js

@@ -0,0 +1,51 @@
+import { pwd } from './pwd.js';
+import { ls } from './ls.js';
+import { cd } from './cd.js';
+import { cat } from './cat.js';
+import { grep } from './grep.js';
+import { cp } from './cp.js';
+import { echo } from './echo.js';
+import { help } from './help.js';
+import { hint } from './hint.js';
+import { clear } from './clear.js';
+import { git } from './git.js';
+import { mkdir } from './mkdir.js';
+import { mv } from './mv.js';
+import { rm } from './rm.js';
+import { find } from './find.js';
+import { touch } from './touch.js';
+import { head } from './head.js';
+import { tail } from './tail.js';
+import { wc } from './wc.js';
+import { sort } from './sort.js';
+import { uniq } from './uniq.js';
+import { cut } from './cut.js';
+import { chmod } from './chmod.js';
+import { man } from './man.js';
+export const commandRegistry = {
+    pwd,
+    ls,
+    cd,
+    cat,
+    grep,
+    cp,
+    echo,
+    help,
+    hint,
+    clear,
+    git,
+    mkdir,
+    mv,
+    rm,
+    find,
+    touch,
+    head,
+    tail,
+    wc,
+    sort,
+    uniq,
+    cut,
+    chmod,
+    man,
+};
+//# sourceMappingURL=index.js.map

package/dist/engine/commands/ls.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function ls(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=ls.d.ts.map

package/dist/engine/commands/ls.js

@@ -0,0 +1,50 @@
+export function ls(fs, args) {
+    let showAll = false;
+    let longFormat = false;
+    const paths = [];
+    for (const arg of args) {
+        if (arg.startsWith('-')) {
+            for (const ch of arg.slice(1)) {
+                if (ch === 'a')
+                    showAll = true;
+                else if (ch === 'l')
+                    longFormat = true;
+                else
+                    return { output: '', error: `ls: invalid option -- '${ch}'` };
+            }
+        }
+        else {
+            paths.push(arg);
+        }
+    }
+    const targetPath = paths.length > 0 ? paths[0] : '.';
+    if (!fs.exists(targetPath)) {
+        return { output: '', error: `ls: cannot access '${targetPath}': No such file or directory` };
+    }
+    if (fs.isFile(targetPath)) {
+        const resolved = fs.resolvePath(targetPath);
+        const name = resolved.split('/').filter(Boolean).pop() ?? resolved;
+        if (longFormat) {
+            const perms = fs.getPermissions(targetPath);
+            return { output: `${perms} ${name}` };
+        }
+        return { output: name };
+    }
+    if (longFormat) {
+        const entries = fs.listDirDetailed(targetPath);
+        const lines = entries
+            .filter(e => showAll || !e.name.startsWith('.'))
+            .map(e => {
+            const resolvedDir = fs.resolvePath(targetPath);
+            const fullPath = resolvedDir === '/' ? `/${e.name}` : `${resolvedDir}/${e.name}`;
+            const perms = fs.getPermissions(fullPath);
+            const suffix = e.type === 'directory' ? '/' : '';
+            return `${perms} ${e.name}${suffix}`;
+        });
+        return { output: lines.join('\n') };
+    }
+    const entries = fs.listDir(targetPath);
+    const filtered = entries.filter(e => showAll || !e.startsWith('.'));
+    return { output: filtered.join('  ') };
+}
+//# sourceMappingURL=ls.js.map

package/dist/engine/commands/man.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function man(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=man.d.ts.map

package/dist/engine/commands/man.js

@@ -0,0 +1,51 @@
+import { commandsMeta } from '../../data/commands-meta.js';
+const categories = {
+    'Navigation': ['pwd', 'cd', 'ls'],
+    'File Operations': ['cat', 'cp', 'mv', 'rm', 'touch', 'mkdir', 'echo'],
+    'Text Processing': ['grep', 'head', 'tail', 'wc', 'sort', 'uniq', 'cut'],
+    'Search': ['find'],
+    'Permissions': ['chmod'],
+    'Version Control': ['git'],
+    'Help': ['help', 'hint', 'man'],
+};
+export function man(fs, args) {
+    if (args.length === 0) {
+        const lines = ['Terminal Quest コマンドリファレンス', ''];
+        for (const [category, cmds] of Object.entries(categories)) {
+            lines.push(`  ${category}:`);
+            for (const cmd of cmds) {
+                const meta = commandsMeta.find(m => m.name === cmd);
+                lines.push(`    ${cmd.padEnd(10)} ${meta?.description ?? ''}`);
+            }
+            lines.push('');
+        }
+        lines.push('詳細: man <コマンド名>');
+        return { output: lines.join('\n') };
+    }
+    const cmdName = args[0];
+    const meta = commandsMeta.find(m => m.name === cmdName);
+    if (!meta) {
+        return { output: '', error: `man: ${cmdName} のマニュアルはありません` };
+    }
+    const lines = [
+        `NAME`,
+        `    ${meta.name} - ${meta.description}`,
+        '',
+        `USAGE`,
+        `    ${meta.usage}`,
+        '',
+    ];
+    if (meta.options && meta.options.length > 0) {
+        lines.push('OPTIONS');
+        for (const opt of meta.options) {
+            lines.push(`    ${opt.flag.padEnd(15)} ${opt.description}`);
+        }
+        lines.push('');
+    }
+    lines.push('EXAMPLES');
+    for (const ex of meta.examples) {
+        lines.push(`    $ ${ex.cmd.padEnd(28)} ${ex.desc}`);
+    }
+    return { output: lines.join('\n') };
+}
+//# sourceMappingURL=man.js.map

package/dist/engine/commands/mkdir.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function mkdir(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=mkdir.d.ts.map

package/dist/engine/commands/mkdir.js

@@ -0,0 +1,31 @@
+export function mkdir(fs, args) {
+    let recursive = false;
+    const paths = [];
+    for (const arg of args) {
+        if (arg === '-p') {
+            recursive = true;
+        }
+        else if (arg.startsWith('-')) {
+            return { output: '', error: `mkdir: invalid option -- '${arg}'` };
+        }
+        else {
+            paths.push(arg);
+        }
+    }
+    if (paths.length === 0) {
+        return { output: '', error: 'mkdir: missing operand' };
+    }
+    for (const path of paths) {
+        if (!recursive && fs.exists(path)) {
+            return { output: '', error: `mkdir: cannot create directory '${path}': File exists` };
+        }
+        try {
+            fs.mkdir(path, recursive);
+        }
+        catch (e) {
+            return { output: '', error: `mkdir: ${e.message}` };
+        }
+    }
+    return { output: '' };
+}
+//# sourceMappingURL=mkdir.js.map

package/dist/engine/commands/mv.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function mv(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=mv.d.ts.map

package/dist/engine/commands/mv.js

@@ -0,0 +1,15 @@
+export function mv(fs, args) {
+    if (args.length < 2) {
+        return { output: '', error: 'mv: missing operand' };
+    }
+    const source = args[0];
+    const dest = args[1];
+    try {
+        fs.move(source, dest);
+    }
+    catch (e) {
+        return { output: '', error: `mv: ${e.message}` };
+    }
+    return { output: '' };
+}
+//# sourceMappingURL=mv.js.map

package/dist/engine/commands/pwd.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function pwd(fs: VirtualFS, _args: string[]): CommandResult;
+//# sourceMappingURL=pwd.d.ts.map

package/dist/engine/commands/pwd.js

@@ -0,0 +1,4 @@
+export function pwd(fs, _args) {
+    return { output: fs.getCwd() };
+}
+//# sourceMappingURL=pwd.js.map

package/dist/engine/commands/rm.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function rm(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=rm.d.ts.map

package/dist/engine/commands/rm.js

@@ -0,0 +1,49 @@
+export function rm(fs, args) {
+    let recursive = false;
+    let force = false;
+    const paths = [];
+    for (const arg of args) {
+        if (arg === '--recursive') {
+            recursive = true;
+        }
+        else if (arg === '--force') {
+            force = true;
+        }
+        else if (arg.startsWith('-') && arg.length > 1 && !arg.startsWith('--')) {
+            for (const ch of arg.slice(1)) {
+                if (ch === 'r' || ch === 'R')
+                    recursive = true;
+                else if (ch === 'f')
+                    force = true;
+                else
+                    return { output: '', error: `rm: invalid option -- '${ch}'` };
+            }
+        }
+        else {
+            paths.push(arg);
+        }
+    }
+    if (paths.length === 0) {
+        if (force)
+            return { output: '' };
+        return { output: '', error: 'rm: missing operand' };
+    }
+    for (const path of paths) {
+        try {
+            if (!fs.exists(path)) {
+                if (!force) {
+                    return { output: '', error: `rm: cannot remove '${path}': No such file or directory` };
+                }
+                continue;
+            }
+            fs.remove(path, recursive);
+        }
+        catch (e) {
+            if (!force) {
+                return { output: '', error: `rm: ${e.message}` };
+            }
+        }
+    }
+    return { output: '' };
+}
+//# sourceMappingURL=rm.js.map

package/dist/engine/commands/sort.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function sort(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=sort.d.ts.map

package/dist/engine/commands/sort.js

@@ -0,0 +1,100 @@
+export function sort(fs, args) {
+    // Extract stdin
+    let stdin;
+    const stdinIdx = args.findIndex(a => a.startsWith('__stdin__:'));
+    if (stdinIdx !== -1) {
+        stdin = args[stdinIdx].slice('__stdin__:'.length);
+        args = [...args.slice(0, stdinIdx), ...args.slice(stdinIdx + 1)];
+    }
+    let reverse = false;
+    let numeric = false;
+    let delimiter;
+    let keyField;
+    const files = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '-t') {
+            i++;
+            if (i >= args.length) {
+                return { output: '', error: 'sort: option requires an argument -- t' };
+            }
+            delimiter = args[i];
+        }
+        else if (arg.startsWith('-t') && arg.length > 2) {
+            delimiter = arg.slice(2);
+        }
+        else if (arg === '-k') {
+            i++;
+            if (i >= args.length) {
+                return { output: '', error: 'sort: option requires an argument -- k' };
+            }
+            keyField = parseInt(args[i], 10);
+            if (isNaN(keyField)) {
+                return { output: '', error: `sort: invalid number at field start: '${args[i]}'` };
+            }
+        }
+        else if (arg.startsWith('-k') && arg.length > 2) {
+            keyField = parseInt(arg.slice(2), 10);
+            if (isNaN(keyField)) {
+                return { output: '', error: `sort: invalid number at field start: '${arg.slice(2)}'` };
+            }
+        }
+        else if (arg.startsWith('-') && arg.length > 1 && !arg.startsWith('--')) {
+            for (const ch of arg.slice(1)) {
+                if (ch === 'r')
+                    reverse = true;
+                else if (ch === 'n')
+                    numeric = true;
+                else
+                    return { output: '', error: `sort: invalid option -- '${ch}'` };
+            }
+        }
+        else {
+            files.push(arg);
+        }
+    }
+    let content;
+    if (files.length > 0) {
+        try {
+            content = fs.readFile(files[0]);
+        }
+        catch (e) {
+            return { output: '', error: `sort: ${e.message}` };
+        }
+    }
+    else if (stdin !== undefined) {
+        content = stdin;
+    }
+    else {
+        return { output: '', error: 'sort: missing file operand' };
+    }
+    const lines = content.split('\n');
+    const getKey = (line) => {
+        if (delimiter !== undefined && keyField !== undefined) {
+            const fields = line.split(delimiter);
+            return fields[keyField - 1] ?? '';
+        }
+        return line;
+    };
+    if (numeric) {
+        lines.sort((a, b) => {
+            const ka = getKey(a);
+            const kb = getKey(b);
+            const na = parseFloat(ka) || 0;
+            const nb = parseFloat(kb) || 0;
+            return na - nb;
+        });
+    }
+    else {
+        lines.sort((a, b) => {
+            const ka = getKey(a);
+            const kb = getKey(b);
+            return ka.localeCompare(kb);
+        });
+    }
+    if (reverse) {
+        lines.reverse();
+    }
+    return { output: lines.join('\n') };
+}
+//# sourceMappingURL=sort.js.map

package/dist/engine/commands/tail.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function tail(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=tail.d.ts.map

package/dist/engine/commands/tail.js

@@ -0,0 +1,59 @@
+export function tail(fs, args) {
+    // Extract stdin
+    let stdin;
+    const stdinIdx = args.findIndex(a => a.startsWith('__stdin__:'));
+    if (stdinIdx !== -1) {
+        stdin = args[stdinIdx].slice('__stdin__:'.length);
+        args = [...args.slice(0, stdinIdx), ...args.slice(stdinIdx + 1)];
+    }
+    let lineCount = 10;
+    const files = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '-n') {
+            i++;
+            if (i >= args.length) {
+                return { output: '', error: 'tail: option requires an argument -- n' };
+            }
+            const n = parseInt(args[i], 10);
+            if (isNaN(n)) {
+                return { output: '', error: `tail: invalid number of lines: '${args[i]}'` };
+            }
+            lineCount = n;
+        }
+        else if (arg.startsWith('-n')) {
+            const n = parseInt(arg.slice(2), 10);
+            if (isNaN(n)) {
+                return { output: '', error: `tail: invalid number of lines: '${arg.slice(2)}'` };
+            }
+            lineCount = n;
+        }
+        else if (arg.startsWith('-')) {
+            return { output: '', error: `tail: invalid option -- '${arg}'` };
+        }
+        else {
+            files.push(arg);
+        }
+    }
+    let content;
+    if (files.length > 0) {
+        try {
+            content = fs.readFile(files[0]);
+        }
+        catch (e) {
+            return { output: '', error: `tail: ${e.message}` };
+        }
+    }
+    else if (stdin !== undefined) {
+        content = stdin;
+    }
+    else {
+        return { output: '', error: 'tail: missing file operand' };
+    }
+    if (content === '')
+        return { output: '' };
+    const lines = content.split('\n');
+    const selected = lines.slice(-lineCount);
+    return { output: selected.join('\n') };
+}
+//# sourceMappingURL=tail.js.map

package/dist/engine/commands/touch.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function touch(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=touch.d.ts.map

package/dist/engine/commands/touch.js

@@ -0,0 +1,18 @@
+export function touch(fs, args) {
+    if (args.length === 0) {
+        return { output: '', error: 'touch: missing file operand' };
+    }
+    const filename = args[0];
+    if (fs.exists(filename)) {
+        // File or directory already exists, do nothing (success)
+        return { output: '' };
+    }
+    try {
+        fs.writeFile(filename, '');
+    }
+    catch (e) {
+        return { output: '', error: `touch: ${e.message}` };
+    }
+    return { output: '' };
+}
+//# sourceMappingURL=touch.js.map

package/dist/engine/commands/uniq.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function uniq(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=uniq.d.ts.map