terminal-quest 1.0.0

package/dist/data/types.d.ts

@@ -0,0 +1,97 @@
+export type ObjectiveCheck = {
+    type: 'command_executed';
+    command: string;
+    args?: string[];
+} | {
+    type: 'output_contains';
+    pattern: string;
+} | {
+    type: 'file_exists';
+    path: string;
+} | {
+    type: 'file_contains';
+    path: string;
+    pattern: string;
+} | {
+    type: 'file_not_exists';
+    path: string;
+} | {
+    type: 'cwd_equals';
+    path: string;
+};
+export interface Hint {
+    level: 1 | 2 | 3;
+    text: string;
+}
+export interface Objective {
+    id: string;
+    description: string;
+    checks: ObjectiveCheck[];
+    hints: Hint[];
+}
+export interface FSNode {
+    type: 'file' | 'directory';
+    content?: string;
+    children?: Record<string, FSNode>;
+    permissions?: string;
+}
+export interface Mission {
+    id: string;
+    title: string;
+    description: string;
+    narrative: string;
+    objectives: Objective[];
+    initialFS: FSNode;
+    initialCwd: string;
+    newCommands?: string[];
+}
+export interface Story {
+    id: string;
+    title: string;
+    description: string;
+    emoji: string;
+    missions: Mission[];
+    unlockRequires: string[];
+    course?: 'kids' | 'beginner' | 'engineer';
+}
+export interface StoryProgress {
+    storyId: string;
+    completedMissions: string[];
+    currentMissionIndex: number;
+    hintsUsed: Record<string, number>;
+}
+export interface Achievement {
+    id: string;
+    title: string;
+    description: string;
+    emoji: string;
+}
+export interface GameProgress {
+    completedStories: string[];
+    storyProgress: Record<string, StoryProgress>;
+    totalCommandsExecuted: number;
+    totalHintsUsed: number;
+    achievements: string[];
+}
+export type Screen = {
+    type: 'title';
+} | {
+    type: 'storySelect';
+} | {
+    type: 'missionBrief';
+    storyId: string;
+    missionIndex: number;
+} | {
+    type: 'terminal';
+    storyId: string;
+    missionIndex: number;
+} | {
+    type: 'missionComplete';
+    storyId: string;
+    missionIndex: number;
+} | {
+    type: 'progress';
+} | {
+    type: 'settings';
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/data/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/engine/Achievements.d.ts

@@ -0,0 +1,5 @@
+import type { Achievement, GameProgress } from '../data/types.js';
+export declare const achievements: Achievement[];
+export declare function checkAchievements(progress: GameProgress, engineerStoryIds: string[]): string[];
+export declare function getAchievement(id: string): Achievement | undefined;
+//# sourceMappingURL=Achievements.d.ts.map

package/dist/engine/Achievements.js

@@ -0,0 +1,93 @@
+export const achievements = [
+    {
+        id: 'first-command',
+        title: '第一歩',
+        description: '最初のコマンドを実行した',
+        emoji: '👣',
+    },
+    {
+        id: 'no-hint-clear',
+        title: 'ヒントなしクリア',
+        description: 'ヒントを使わずにミッションをクリアした',
+        emoji: '🧠',
+    },
+    {
+        id: 'story-complete',
+        title: 'ストーリーマスター',
+        description: 'ストーリーを1つクリアした',
+        emoji: '📖',
+    },
+    {
+        id: 'all-engineer',
+        title: 'エンジニアコース制覇',
+        description: 'エンジニアコースの全ストーリーをクリアした',
+        emoji: '🎓',
+    },
+    {
+        id: 'commands-100',
+        title: 'コマンド100回',
+        description: 'コマンドを100回実行した',
+        emoji: '💯',
+    },
+    {
+        id: 'commands-500',
+        title: 'ベテラン',
+        description: 'コマンドを500回実行した',
+        emoji: '⭐',
+    },
+    {
+        id: 'pipe-master',
+        title: 'パイプの達人',
+        description: 'Story 6「パイプの達人」をクリアした',
+        emoji: '🔗',
+    },
+];
+export function checkAchievements(progress, engineerStoryIds) {
+    const newAchievements = [];
+    const existing = progress.achievements ?? [];
+    // first-command: executed at least 1 command
+    if (!existing.includes('first-command') && progress.totalCommandsExecuted >= 1) {
+        newAchievements.push('first-command');
+    }
+    // no-hint-clear: any mission completed with 0 hints
+    if (!existing.includes('no-hint-clear')) {
+        for (const sp of Object.values(progress.storyProgress)) {
+            for (const missionId of sp.completedMissions) {
+                if ((sp.hintsUsed[missionId] ?? 0) === 0) {
+                    newAchievements.push('no-hint-clear');
+                    break;
+                }
+            }
+            if (newAchievements.includes('no-hint-clear'))
+                break;
+        }
+    }
+    // story-complete: at least 1 story completed
+    if (!existing.includes('story-complete') && progress.completedStories.length >= 1) {
+        newAchievements.push('story-complete');
+    }
+    // all-engineer: all engineer course stories completed
+    if (!existing.includes('all-engineer') && engineerStoryIds.length > 0) {
+        const allDone = engineerStoryIds.every(id => progress.completedStories.includes(id));
+        if (allDone) {
+            newAchievements.push('all-engineer');
+        }
+    }
+    // commands-100
+    if (!existing.includes('commands-100') && progress.totalCommandsExecuted >= 100) {
+        newAchievements.push('commands-100');
+    }
+    // commands-500
+    if (!existing.includes('commands-500') && progress.totalCommandsExecuted >= 500) {
+        newAchievements.push('commands-500');
+    }
+    // pipe-master: story-06 completed
+    if (!existing.includes('pipe-master') && progress.completedStories.includes('story-06')) {
+        newAchievements.push('pipe-master');
+    }
+    return newAchievements;
+}
+export function getAchievement(id) {
+    return achievements.find(a => a.id === id);
+}
+//# sourceMappingURL=Achievements.js.map

package/dist/engine/CommandHandler.d.ts

@@ -0,0 +1,17 @@
+import { VirtualFS } from './VirtualFS.js';
+import { type CommandResult } from './commands/index.js';
+export declare class CommandHandler {
+    private fs;
+    constructor(fs: VirtualFS);
+    execute(input: string): CommandResult;
+    private executePipeline;
+    private executeSingle;
+    private extractRedirect;
+    private splitOnPipe;
+    /**
+     * Tokenize input string, handling single and double quotes.
+     * Quoted strings preserve internal spaces. Quotes are removed from the result.
+     */
+    private tokenize;
+}
+//# sourceMappingURL=CommandHandler.d.ts.map

package/dist/engine/CommandHandler.js

@@ -0,0 +1,177 @@
+import { commandRegistry } from './commands/index.js';
+export class CommandHandler {
+    fs;
+    constructor(fs) {
+        this.fs = fs;
+    }
+    execute(input) {
+        const trimmed = input.trim();
+        if (trimmed === '') {
+            return { output: '' };
+        }
+        // Check for pipe: split on unquoted '|'
+        const pipeSegments = this.splitOnPipe(trimmed);
+        if (pipeSegments.length > 1) {
+            return this.executePipeline(pipeSegments);
+        }
+        return this.executeSingle(trimmed);
+    }
+    executePipeline(segments) {
+        let previousOutput = '';
+        for (let i = 0; i < segments.length; i++) {
+            const segment = segments[i].trim();
+            if (segment === '') {
+                return { output: '', error: 'syntax error near unexpected token `|`' };
+            }
+            // For piped commands, pass previous output as stdin via args if applicable
+            const result = this.executeSingle(segment, previousOutput);
+            if (result.error) {
+                return result;
+            }
+            previousOutput = result.output;
+        }
+        return { output: previousOutput };
+    }
+    executeSingle(input, stdin) {
+        // Parse redirect operators from the input before tokenizing fully
+        const { command: commandPart, redirect } = this.extractRedirect(input);
+        const tokens = this.tokenize(commandPart);
+        if (tokens.length === 0) {
+            return { output: '' };
+        }
+        const commandName = tokens[0];
+        const args = tokens.slice(1);
+        const commandFn = commandRegistry[commandName];
+        if (!commandFn) {
+            return { output: '', error: `${commandName}: command not found` };
+        }
+        // Pass stdin via special arg marker for pipe support
+        const finalArgs = stdin != null && stdin !== ''
+            ? [...args, `__stdin__:${stdin}`]
+            : args;
+        const result = commandFn(this.fs, finalArgs);
+        // Handle redirect
+        if (redirect && !result.error) {
+            try {
+                if (redirect.mode === 'overwrite') {
+                    this.fs.writeFile(redirect.target, result.output);
+                }
+                else {
+                    this.fs.appendFile(redirect.target, result.output);
+                }
+                return { output: '' };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return { output: '', error: msg };
+            }
+        }
+        return result;
+    }
+    extractRedirect(input) {
+        // Look for >> or > outside of quotes
+        let inSingle = false;
+        let inDouble = false;
+        let redirectIndex = -1;
+        let isAppend = false;
+        for (let i = 0; i < input.length; i++) {
+            const ch = input[i];
+            if (ch === "'" && !inDouble) {
+                inSingle = !inSingle;
+            }
+            else if (ch === '"' && !inSingle) {
+                inDouble = !inDouble;
+            }
+            else if (!inSingle && !inDouble) {
+                if (ch === '>' && i + 1 < input.length && input[i + 1] === '>') {
+                    redirectIndex = i;
+                    isAppend = true;
+                    break;
+                }
+                else if (ch === '>') {
+                    redirectIndex = i;
+                    isAppend = false;
+                    break;
+                }
+            }
+        }
+        if (redirectIndex === -1) {
+            return { command: input, redirect: null };
+        }
+        const commandPart = input.slice(0, redirectIndex).trim();
+        const targetPart = input.slice(redirectIndex + (isAppend ? 2 : 1)).trim();
+        // Tokenize the target to handle potential quotes
+        const targetTokens = this.tokenize(targetPart);
+        if (targetTokens.length === 0) {
+            return { command: input, redirect: null };
+        }
+        return {
+            command: commandPart,
+            redirect: {
+                mode: isAppend ? 'append' : 'overwrite',
+                target: targetTokens[0],
+            },
+        };
+    }
+    splitOnPipe(input) {
+        const segments = [];
+        let current = '';
+        let inSingle = false;
+        let inDouble = false;
+        for (let i = 0; i < input.length; i++) {
+            const ch = input[i];
+            if (ch === "'" && !inDouble) {
+                inSingle = !inSingle;
+                current += ch;
+            }
+            else if (ch === '"' && !inSingle) {
+                inDouble = !inDouble;
+                current += ch;
+            }
+            else if (ch === '|' && !inSingle && !inDouble) {
+                segments.push(current);
+                current = '';
+            }
+            else {
+                current += ch;
+            }
+        }
+        segments.push(current);
+        return segments;
+    }
+    /**
+     * Tokenize input string, handling single and double quotes.
+     * Quoted strings preserve internal spaces. Quotes are removed from the result.
+     */
+    tokenize(input) {
+        const tokens = [];
+        let current = '';
+        let inSingle = false;
+        let inDouble = false;
+        for (let i = 0; i < input.length; i++) {
+            const ch = input[i];
+            if (ch === "'" && !inDouble) {
+                inSingle = !inSingle;
+                // Don't add the quote character to the token
+            }
+            else if (ch === '"' && !inSingle) {
+                inDouble = !inDouble;
+                // Don't add the quote character to the token
+            }
+            else if (ch === ' ' && !inSingle && !inDouble) {
+                if (current.length > 0) {
+                    tokens.push(current);
+                    current = '';
+                }
+            }
+            else {
+                current += ch;
+            }
+        }
+        if (current.length > 0) {
+            tokens.push(current);
+        }
+        return tokens;
+    }
+}
+//# sourceMappingURL=CommandHandler.js.map

package/dist/engine/HintEngine.d.ts

@@ -0,0 +1,10 @@
+import type { Hint } from '../data/types.js';
+export declare class HintEngine {
+    private currentHintLevel;
+    private totalHintsUsed;
+    constructor();
+    getNextHint(objectiveId: string, hints: Hint[]): Hint | null;
+    getCurrentLevel(objectiveId: string): number;
+    getTotalHintsUsed(): number;
+}
+//# sourceMappingURL=HintEngine.d.ts.map

package/dist/engine/HintEngine.js

@@ -0,0 +1,26 @@
+export class HintEngine {
+    currentHintLevel;
+    totalHintsUsed;
+    constructor() {
+        this.currentHintLevel = {};
+        this.totalHintsUsed = 0;
+    }
+    getNextHint(objectiveId, hints) {
+        const currentLevel = this.currentHintLevel[objectiveId] ?? 0;
+        const nextLevel = currentLevel + 1;
+        const hint = hints.find((h) => h.level === nextLevel);
+        if (!hint) {
+            return null;
+        }
+        this.currentHintLevel[objectiveId] = nextLevel;
+        this.totalHintsUsed++;
+        return hint;
+    }
+    getCurrentLevel(objectiveId) {
+        return this.currentHintLevel[objectiveId] ?? 0;
+    }
+    getTotalHintsUsed() {
+        return this.totalHintsUsed;
+    }
+}
+//# sourceMappingURL=HintEngine.js.map

package/dist/engine/MissionEngine.d.ts

@@ -0,0 +1,17 @@
+import type { Mission } from '../data/types.js';
+import { VirtualFS } from './VirtualFS.js';
+export declare class MissionEngine {
+    private fs;
+    private mission;
+    private completedObjectives;
+    private commandHistory;
+    constructor(mission: Mission);
+    getFS(): VirtualFS;
+    getMission(): Mission;
+    getCompletedObjectives(): string[];
+    getCurrentObjectiveIndex(): number;
+    isAllComplete(): boolean;
+    checkObjectives(command: string, args: string[], output: string): string[];
+    private evaluateCheck;
+}
+//# sourceMappingURL=MissionEngine.d.ts.map

package/dist/engine/MissionEngine.js

@@ -0,0 +1,84 @@
+import { VirtualFS } from './VirtualFS.js';
+export class MissionEngine {
+    fs;
+    mission;
+    completedObjectives;
+    commandHistory;
+    constructor(mission) {
+        this.mission = mission;
+        this.fs = new VirtualFS(mission.initialFS, mission.initialCwd);
+        this.completedObjectives = new Set();
+        this.commandHistory = [];
+    }
+    getFS() {
+        return this.fs;
+    }
+    getMission() {
+        return this.mission;
+    }
+    getCompletedObjectives() {
+        return [...this.completedObjectives];
+    }
+    getCurrentObjectiveIndex() {
+        for (let i = 0; i < this.mission.objectives.length; i++) {
+            if (!this.completedObjectives.has(this.mission.objectives[i].id)) {
+                return i;
+            }
+        }
+        return this.mission.objectives.length;
+    }
+    isAllComplete() {
+        return this.mission.objectives.every((obj) => this.completedObjectives.has(obj.id));
+    }
+    checkObjectives(command, args, output) {
+        this.commandHistory.push({ command, args, output });
+        const newlyCompleted = [];
+        for (const objective of this.mission.objectives) {
+            if (this.completedObjectives.has(objective.id)) {
+                continue;
+            }
+            const allChecksPassed = objective.checks.every((check) => this.evaluateCheck(check, command, args, output));
+            if (allChecksPassed) {
+                this.completedObjectives.add(objective.id);
+                newlyCompleted.push(objective.id);
+            }
+        }
+        return newlyCompleted;
+    }
+    evaluateCheck(check, command, args, output) {
+        switch (check.type) {
+            case 'command_executed': {
+                if (check.command !== command)
+                    return false;
+                if (check.args) {
+                    return check.args.every((expected, i) => args[i] === expected);
+                }
+                return true;
+            }
+            case 'output_contains': {
+                return output.includes(check.pattern);
+            }
+            case 'file_exists': {
+                return this.fs.exists(check.path);
+            }
+            case 'file_contains': {
+                try {
+                    const content = this.fs.readFile(check.path);
+                    return content.includes(check.pattern);
+                }
+                catch {
+                    return false;
+                }
+            }
+            case 'file_not_exists': {
+                return !this.fs.exists(check.path);
+            }
+            case 'cwd_equals': {
+                return this.fs.getCwd() === check.path;
+            }
+            default:
+                return false;
+        }
+    }
+}
+//# sourceMappingURL=MissionEngine.js.map

package/dist/engine/TabCompletion.d.ts

@@ -0,0 +1,14 @@
+import { VirtualFS } from './VirtualFS.js';
+export interface CompletionResult {
+    completed: string;
+    candidates: string[];
+}
+export declare class TabCompletion {
+    private fs;
+    constructor(fs: VirtualFS);
+    complete(input: string): CompletionResult;
+    private completeCommand;
+    private completePath;
+    private longestCommonPrefix;
+}
+//# sourceMappingURL=TabCompletion.d.ts.map

package/dist/engine/TabCompletion.js

@@ -0,0 +1,93 @@
+import { commandRegistry } from './commands/index.js';
+export class TabCompletion {
+    fs;
+    constructor(fs) {
+        this.fs = fs;
+    }
+    complete(input) {
+        if (input === '') {
+            return { completed: '', candidates: [] };
+        }
+        const parts = input.split(/\s+/);
+        const endsWithSpace = input.endsWith(' ');
+        if (parts.length === 1 && !endsWithSpace) {
+            return this.completeCommand(parts[0]);
+        }
+        const partial = endsWithSpace ? '' : parts[parts.length - 1];
+        const prefix = endsWithSpace ? input : parts.slice(0, -1).join(' ') + ' ';
+        const result = this.completePath(partial);
+        return {
+            completed: prefix + result.completed,
+            candidates: result.candidates,
+        };
+    }
+    completeCommand(partial) {
+        const commands = Object.keys(commandRegistry);
+        const matches = commands.filter(cmd => cmd.startsWith(partial));
+        if (matches.length === 0) {
+            return { completed: partial, candidates: [] };
+        }
+        if (matches.length === 1) {
+            return { completed: matches[0] + ' ', candidates: [] };
+        }
+        const common = this.longestCommonPrefix(matches);
+        return { completed: common, candidates: matches };
+    }
+    completePath(partial) {
+        let dirPath;
+        let filePrefix;
+        const lastSlash = partial.lastIndexOf('/');
+        if (lastSlash === -1) {
+            dirPath = '.';
+            filePrefix = partial;
+        }
+        else {
+            dirPath = partial.slice(0, lastSlash) || '/';
+            filePrefix = partial.slice(lastSlash + 1);
+        }
+        try {
+            if (!this.fs.exists(dirPath) || !this.fs.isDirectory(dirPath)) {
+                return { completed: partial, candidates: [] };
+            }
+            const entries = this.fs.listDirDetailed(dirPath);
+            const matches = entries.filter(e => e.name.startsWith(filePrefix));
+            if (matches.length === 0) {
+                return { completed: partial, candidates: [] };
+            }
+            const dirPrefix = lastSlash === -1 ? '' : partial.slice(0, lastSlash + 1);
+            if (matches.length === 1) {
+                const match = matches[0];
+                const suffix = match.type === 'directory' ? '/' : ' ';
+                return { completed: dirPrefix + match.name + suffix, candidates: [] };
+            }
+            const matchNames = matches.map(m => m.name);
+            const common = this.longestCommonPrefix(matchNames);
+            return {
+                completed: dirPrefix + common,
+                candidates: matchNames.map(n => {
+                    const entry = matches.find(m => m.name === n);
+                    return entry.type === 'directory' ? n + '/' : n;
+                }),
+            };
+        }
+        catch {
+            return { completed: partial, candidates: [] };
+        }
+    }
+    longestCommonPrefix(strings) {
+        if (strings.length === 0)
+            return '';
+        if (strings.length === 1)
+            return strings[0];
+        let prefix = strings[0];
+        for (let i = 1; i < strings.length; i++) {
+            while (!strings[i].startsWith(prefix)) {
+                prefix = prefix.slice(0, -1);
+                if (prefix === '')
+                    return '';
+            }
+        }
+        return prefix;
+    }
+}
+//# sourceMappingURL=TabCompletion.js.map

package/dist/engine/VirtualFS.d.ts

@@ -0,0 +1,33 @@
+import type { FSNode } from '../data/types.js';
+export declare class VirtualFS {
+    private root;
+    private cwd;
+    constructor(initialFS: FSNode, initialCwd?: string);
+    private deepClone;
+    getCwd(): string;
+    resolvePath(path: string): string;
+    private normalizePath;
+    private getNode;
+    private getParentAndName;
+    exists(path: string): boolean;
+    isDirectory(path: string): boolean;
+    isFile(path: string): boolean;
+    readFile(path: string): string;
+    writeFile(path: string, content: string): void;
+    appendFile(path: string, content: string): void;
+    listDir(path: string): string[];
+    listDirDetailed(path: string): Array<{
+        name: string;
+        type: 'file' | 'directory';
+    }>;
+    mkdir(path: string, recursive?: boolean): void;
+    private mkdirSingle;
+    remove(path: string, recursive?: boolean): void;
+    copy(src: string, dest: string, recursive?: boolean): void;
+    move(src: string, dest: string): void;
+    changeCwd(path: string): void;
+    getPermissions(path: string): string;
+    setPermissions(path: string, permissions: string): void;
+    find(startPath: string, predicate: (path: string, node: FSNode) => boolean): string[];
+}
+//# sourceMappingURL=VirtualFS.d.ts.map