reqon-dsl 0.2.0

package/dist/lexer/tokens.js

@@ -0,0 +1,146 @@
+// Extend Vague's TokenType with Reqon-specific tokens
+export var ReqonTokenType;
+(function (ReqonTokenType) {
+    // Reqon keywords
+    ReqonTokenType["MISSION"] = "MISSION";
+    ReqonTokenType["ACTION"] = "ACTION";
+    ReqonTokenType["SOURCE"] = "SOURCE";
+    ReqonTokenType["STORE"] = "STORE";
+    ReqonTokenType["CALL"] = "CALL";
+    ReqonTokenType["RUN"] = "RUN";
+    ReqonTokenType["FOR"] = "FOR";
+    ReqonTokenType["MAP"] = "MAP";
+    ReqonTokenType["EACH"] = "EACH";
+    ReqonTokenType["PAGINATE"] = "PAGINATE";
+    ReqonTokenType["UNTIL"] = "UNTIL";
+    ReqonTokenType["RETRY"] = "RETRY";
+    ReqonTokenType["KEY"] = "KEY";
+    ReqonTokenType["PARTIAL"] = "PARTIAL";
+    ReqonTokenType["UPSERT"] = "UPSERT";
+    ReqonTokenType["SINCE"] = "SINCE";
+    ReqonTokenType["LAST_SYNC"] = "LAST_SYNC";
+    // HTTP methods
+    ReqonTokenType["GET"] = "GET";
+    ReqonTokenType["POST"] = "POST";
+    ReqonTokenType["PUT"] = "PUT";
+    ReqonTokenType["PATCH"] = "PATCH";
+    ReqonTokenType["DELETE"] = "DELETE";
+    // Store types
+    ReqonTokenType["NOSQL"] = "NOSQL";
+    ReqonTokenType["SQL"] = "SQL";
+    ReqonTokenType["MEMORY"] = "MEMORY";
+    // Auth types
+    ReqonTokenType["OAUTH2"] = "OAUTH2";
+    ReqonTokenType["BEARER"] = "BEARER";
+    ReqonTokenType["BASIC"] = "BASIC";
+    ReqonTokenType["API_KEY"] = "API_KEY";
+    ReqonTokenType["NONE"] = "NONE";
+    // Pagination types
+    ReqonTokenType["OFFSET"] = "OFFSET";
+    ReqonTokenType["CURSOR"] = "CURSOR";
+    ReqonTokenType["PAGE"] = "PAGE";
+    // Additional operators (RIGHT_ARROW is now in Vague)
+    ReqonTokenType["NOT_EQUALS"] = "NOT_EQUALS";
+    ReqonTokenType["BANG"] = "BANG";
+    // OAS integration
+    ReqonTokenType["FROM"] = "FROM";
+    // Scheduling
+    ReqonTokenType["SCHEDULE"] = "SCHEDULE";
+    ReqonTokenType["CRON"] = "CRON";
+    ReqonTokenType["EVERY"] = "EVERY";
+    ReqonTokenType["AT"] = "AT";
+    ReqonTokenType["HOURS"] = "HOURS";
+    ReqonTokenType["MINUTES"] = "MINUTES";
+    ReqonTokenType["SECONDS"] = "SECONDS";
+    ReqonTokenType["DAYS"] = "DAYS";
+    ReqonTokenType["WEEKS"] = "WEEKS";
+    // Flow control directives
+    ReqonTokenType["CONTINUE"] = "CONTINUE";
+    ReqonTokenType["SKIP"] = "SKIP";
+    ReqonTokenType["ABORT"] = "ABORT";
+    ReqonTokenType["QUEUE"] = "QUEUE";
+    ReqonTokenType["JUMP"] = "JUMP";
+    // Type checking
+    ReqonTokenType["IS"] = "IS";
+    // Webhook support
+    ReqonTokenType["WAIT"] = "WAIT";
+    ReqonTokenType["TIMEOUT"] = "TIMEOUT";
+    ReqonTokenType["PATH"] = "PATH";
+    ReqonTokenType["EXPECTED_EVENTS"] = "EXPECTED_EVENTS";
+    ReqonTokenType["EVENT_FILTER"] = "EVENT_FILTER";
+    ReqonTokenType["STORAGE"] = "STORAGE";
+})(ReqonTokenType || (ReqonTokenType = {}));
+// Re-export Vague's TokenType for convenience
+export { TokenType as VagueTokenType } from 'vague-lang';
+// Reqon-specific keywords
+export const REQON_KEYWORDS = {
+    mission: ReqonTokenType.MISSION,
+    action: ReqonTokenType.ACTION,
+    source: ReqonTokenType.SOURCE,
+    store: ReqonTokenType.STORE,
+    call: ReqonTokenType.CALL,
+    run: ReqonTokenType.RUN,
+    for: ReqonTokenType.FOR,
+    map: ReqonTokenType.MAP,
+    each: ReqonTokenType.EACH,
+    paginate: ReqonTokenType.PAGINATE,
+    until: ReqonTokenType.UNTIL,
+    retry: ReqonTokenType.RETRY,
+    key: ReqonTokenType.KEY,
+    partial: ReqonTokenType.PARTIAL,
+    upsert: ReqonTokenType.UPSERT,
+    since: ReqonTokenType.SINCE,
+    lastSync: ReqonTokenType.LAST_SYNC,
+    // HTTP methods (both lowercase and uppercase)
+    get: ReqonTokenType.GET,
+    post: ReqonTokenType.POST,
+    put: ReqonTokenType.PUT,
+    patch: ReqonTokenType.PATCH,
+    delete: ReqonTokenType.DELETE,
+    GET: ReqonTokenType.GET,
+    POST: ReqonTokenType.POST,
+    PUT: ReqonTokenType.PUT,
+    PATCH: ReqonTokenType.PATCH,
+    DELETE: ReqonTokenType.DELETE,
+    // Store types
+    nosql: ReqonTokenType.NOSQL,
+    sql: ReqonTokenType.SQL,
+    memory: ReqonTokenType.MEMORY,
+    // Auth types
+    oauth2: ReqonTokenType.OAUTH2,
+    bearer: ReqonTokenType.BEARER,
+    basic: ReqonTokenType.BASIC,
+    api_key: ReqonTokenType.API_KEY,
+    none: ReqonTokenType.NONE,
+    // Pagination types
+    offset: ReqonTokenType.OFFSET,
+    cursor: ReqonTokenType.CURSOR,
+    page: ReqonTokenType.PAGE,
+    // OAS integration
+    from: ReqonTokenType.FROM,
+    // Scheduling
+    schedule: ReqonTokenType.SCHEDULE,
+    cron: ReqonTokenType.CRON,
+    every: ReqonTokenType.EVERY,
+    at: ReqonTokenType.AT,
+    hours: ReqonTokenType.HOURS,
+    minutes: ReqonTokenType.MINUTES,
+    seconds: ReqonTokenType.SECONDS,
+    days: ReqonTokenType.DAYS,
+    weeks: ReqonTokenType.WEEKS,
+    // Flow control directives
+    continue: ReqonTokenType.CONTINUE,
+    skip: ReqonTokenType.SKIP,
+    abort: ReqonTokenType.ABORT,
+    queue: ReqonTokenType.QUEUE,
+    jump: ReqonTokenType.JUMP,
+    // Type checking
+    is: ReqonTokenType.IS,
+    // Webhook support
+    wait: ReqonTokenType.WAIT,
+    timeout: ReqonTokenType.TIMEOUT,
+    path: ReqonTokenType.PATH,
+    expectedEvents: ReqonTokenType.EXPECTED_EVENTS,
+    eventFilter: ReqonTokenType.EVENT_FILTER,
+    storage: ReqonTokenType.STORAGE,
+};

package/dist/loader/index.d.ts

@@ -0,0 +1,36 @@
+import type { ReqonProgram } from '../ast/nodes.js';
+export interface LoadResult {
+    program: ReqonProgram;
+    /** Base directory for the mission (folder path or file's parent) */
+    baseDir: string;
+    /** All source files that were loaded */
+    sourceFiles: string[];
+}
+/** Supported file extensions, in order of preference */
+export declare const SUPPORTED_EXTENSIONS: readonly [".vague", ".reqon"];
+export type SupportedExtension = (typeof SUPPORTED_EXTENSIONS)[number];
+export interface LoadOptions {
+    /** File extension to look for (default: tries '.vague' then '.reqon') */
+    extension?: SupportedExtension;
+}
+/**
+ * Load a mission from a file or folder.
+ *
+ * Single file mode:
+ *   loadMission('./sync-invoices.reqon')
+ *   Returns the parsed program from that file.
+ *
+ * Folder mode:
+ *   loadMission('./sync-invoices/')
+ *   Looks for mission.reqon (root) and merges all *.reqon action files.
+ *   Actions are resolved by name from the `run` pipeline.
+ */
+export declare function loadMission(path: string, options?: LoadOptions): Promise<LoadResult>;
+/**
+ * Check if a path is a mission folder (contains mission.vague or mission.reqon)
+ */
+export declare function isMissionFolder(path: string): Promise<boolean>;
+/**
+ * Get the mission name from a path (folder name or file name without extension)
+ */
+export declare function getMissionName(path: string): string;

package/dist/loader/index.js

@@ -0,0 +1,220 @@
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { resolve, join, dirname, basename } from 'node:path';
+import { ReqonLexer } from '../lexer/index.js';
+import { ReqonParser } from '../parser/index.js';
+/** Supported file extensions, in order of preference */
+export const SUPPORTED_EXTENSIONS = ['.vague', '.reqon'];
+/**
+ * Load a mission from a file or folder.
+ *
+ * Single file mode:
+ *   loadMission('./sync-invoices.reqon')
+ *   Returns the parsed program from that file.
+ *
+ * Folder mode:
+ *   loadMission('./sync-invoices/')
+ *   Looks for mission.reqon (root) and merges all *.reqon action files.
+ *   Actions are resolved by name from the `run` pipeline.
+ */
+export async function loadMission(path, options = {}) {
+    const absolutePath = resolve(path);
+    const stats = await stat(absolutePath);
+    if (stats.isDirectory()) {
+        return loadMissionFolder(absolutePath, options);
+    }
+    else {
+        return loadMissionFile(absolutePath);
+    }
+}
+/**
+ * Load a single .reqon file
+ */
+async function loadMissionFile(filePath) {
+    const source = await readFile(filePath, 'utf-8');
+    const program = parseSource(source, filePath);
+    return {
+        program,
+        baseDir: dirname(filePath),
+        sourceFiles: [filePath],
+    };
+}
+/**
+ * Load a mission from a folder.
+ *
+ * Expected structure:
+ *   mission-name/
+ *   ├── mission.reqon      # Root file with mission definition (sources, stores, pipeline)
+ *   ├── fetch-list.reqon   # Action file
+ *   ├── hydrate.reqon      # Action file
+ *   └── normalize.reqon    # Action file
+ *
+ * The root file (mission.reqon) contains:
+ * - source definitions
+ * - store definitions
+ * - schema definitions
+ * - the pipeline (run X then Y then Z)
+ * - optionally inline actions
+ *
+ * Action files contain standalone action definitions that get merged in.
+ */
+async function loadMissionFolder(folderPath, options) {
+    // Find root file - try extensions in order of preference
+    const extensionsToTry = options.extension
+        ? [options.extension]
+        : SUPPORTED_EXTENSIONS;
+    let rootFilePath = null;
+    let ext = null;
+    for (const extension of extensionsToTry) {
+        const candidatePath = join(folderPath, `mission${extension}`);
+        try {
+            await stat(candidatePath);
+            rootFilePath = candidatePath;
+            ext = extension;
+            break;
+        }
+        catch {
+            // Try next extension
+        }
+    }
+    if (!rootFilePath || !ext) {
+        const tried = extensionsToTry.map(e => `mission${e}`).join(' or ');
+        throw new Error(`Mission folder must contain a root file (${tried}). ` +
+            `Not found in: ${folderPath}`);
+    }
+    // Load root file
+    const rootSource = await readFile(rootFilePath, 'utf-8');
+    const rootProgram = parseSource(rootSource, rootFilePath);
+    // Find all other action files in the folder (same extension as root)
+    const rootFileName = basename(rootFilePath);
+    const files = await readdir(folderPath);
+    const actionFiles = files.filter(f => f.endsWith(ext) && f !== rootFileName);
+    const sourceFiles = [rootFilePath];
+    const externalActions = [];
+    // Parse each action file
+    for (const file of actionFiles) {
+        const filePath = join(folderPath, file);
+        sourceFiles.push(filePath);
+        const source = await readFile(filePath, 'utf-8');
+        const actionProgram = parseSource(source, filePath);
+        // Extract action definitions from the file
+        for (const stmt of actionProgram.statements) {
+            if (stmt.type === 'ActionDefinition') {
+                externalActions.push(stmt);
+            }
+            else if (stmt.type === 'MissionDefinition') {
+                throw new Error(`Action file '${file}' should not contain a mission definition. ` +
+                    `Only '${rootFileName}' should define the mission.`);
+            }
+        }
+    }
+    // Merge external actions into the mission
+    const mergedProgram = mergeActions(rootProgram, externalActions);
+    // Validate that all actions referenced in the pipeline exist
+    validatePipelineActions(mergedProgram);
+    return {
+        program: mergedProgram,
+        baseDir: folderPath,
+        sourceFiles,
+    };
+}
+/**
+ * Parse source code into a program
+ */
+function parseSource(source, filePath) {
+    const lexer = new ReqonLexer(source);
+    const tokens = lexer.tokenize();
+    const parser = new ReqonParser(tokens, source, filePath);
+    return parser.parse();
+}
+/**
+ * Merge external actions into the mission definition
+ */
+function mergeActions(program, externalActions) {
+    // Find the mission in the program
+    const missionIndex = program.statements.findIndex((s) => s.type === 'MissionDefinition');
+    if (missionIndex === -1) {
+        throw new Error('Root file must contain a mission definition');
+    }
+    const mission = program.statements[missionIndex];
+    // Build a map of existing actions
+    const actionMap = new Map();
+    for (const action of mission.actions) {
+        actionMap.set(action.name, action);
+    }
+    // Add external actions (error if duplicate)
+    for (const action of externalActions) {
+        if (actionMap.has(action.name)) {
+            throw new Error(`Duplicate action definition: '${action.name}'. ` +
+                `Action names must be unique across all files.`);
+        }
+        actionMap.set(action.name, action);
+    }
+    // Create updated mission with all actions
+    const updatedMission = {
+        ...mission,
+        actions: Array.from(actionMap.values()),
+    };
+    // Return updated program
+    const updatedStatements = [...program.statements];
+    updatedStatements[missionIndex] = updatedMission;
+    return {
+        type: 'ReqonProgram',
+        statements: updatedStatements,
+    };
+}
+/**
+ * Validate that all actions referenced in the pipeline exist
+ */
+function validatePipelineActions(program) {
+    const mission = program.statements.find((s) => s.type === 'MissionDefinition');
+    if (!mission)
+        return;
+    const actionNames = new Set(mission.actions.map(a => a.name));
+    for (const stage of mission.pipeline.stages) {
+        const stageActions = stage.actions ?? (stage.action ? [stage.action] : []);
+        for (const actionName of stageActions) {
+            if (!actionNames.has(actionName)) {
+                throw new Error(`Pipeline references unknown action: '${actionName}'. ` +
+                    `Available actions: ${Array.from(actionNames).join(', ')}`);
+            }
+        }
+    }
+}
+/**
+ * Check if a path is a mission folder (contains mission.vague or mission.reqon)
+ */
+export async function isMissionFolder(path) {
+    try {
+        const absolutePath = resolve(path);
+        const stats = await stat(absolutePath);
+        if (!stats.isDirectory())
+            return false;
+        // Check for any supported root file
+        for (const ext of SUPPORTED_EXTENSIONS) {
+            try {
+                await stat(join(absolutePath, `mission${ext}`));
+                return true;
+            }
+            catch {
+                // Try next extension
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the mission name from a path (folder name or file name without extension)
+ */
+export function getMissionName(path) {
+    const absolutePath = resolve(path);
+    const name = basename(absolutePath);
+    for (const ext of SUPPORTED_EXTENSIONS) {
+        if (name.endsWith(ext)) {
+            return name.slice(0, -ext.length);
+        }
+    }
+    return name;
+}

package/dist/loader/loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/loader/loader.test.js

@@ -0,0 +1,287 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdir, writeFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { loadMission, isMissionFolder, getMissionName } from './index.js';
+const TEST_DIR = '.test-missions';
+describe('Mission Loader', () => {
+    beforeEach(async () => {
+        await mkdir(TEST_DIR, { recursive: true });
+    });
+    afterEach(async () => {
+        await rm(TEST_DIR, { recursive: true, force: true });
+    });
+    describe('single file loading', () => {
+        it('loads a single .reqon file', async () => {
+            const filePath = join(TEST_DIR, 'simple.reqon');
+            await writeFile(filePath, `
+        mission Simple {
+          source Api {
+            auth: none,
+            base: "https://api.example.com"
+          }
+
+          store data: memory("items")
+
+          action Fetch {
+            fetch GET "/items" { source: Api }
+            store response -> data
+          }
+
+          run Fetch
+        }
+      `);
+            const result = await loadMission(filePath);
+            expect(result.sourceFiles).toHaveLength(1);
+            expect(result.sourceFiles[0]).toContain('simple.reqon');
+            const mission = result.program.statements.find(s => s.type === 'MissionDefinition');
+            expect(mission).toBeDefined();
+            expect(mission.name).toBe('Simple');
+            expect(mission.actions).toHaveLength(1);
+        });
+        it('loads a single .vague file', async () => {
+            const filePath = join(TEST_DIR, 'simple.vague');
+            await writeFile(filePath, `
+        mission Simple {
+          source Api {
+            auth: none,
+            base: "https://api.example.com"
+          }
+
+          store data: memory("items")
+
+          action Fetch {
+            fetch GET "/items" { source: Api }
+            store response -> data
+          }
+
+          run Fetch
+        }
+      `);
+            const result = await loadMission(filePath);
+            expect(result.sourceFiles).toHaveLength(1);
+            expect(result.sourceFiles[0]).toContain('simple.vague');
+            const mission = result.program.statements.find(s => s.type === 'MissionDefinition');
+            expect(mission).toBeDefined();
+            expect(mission.name).toBe('Simple');
+        });
+    });
+    describe('folder loading', () => {
+        it('loads mission from folder with separate action files', async () => {
+            const missionDir = join(TEST_DIR, 'sync-invoices');
+            await mkdir(missionDir, { recursive: true });
+            // Root mission file
+            await writeFile(join(missionDir, 'mission.reqon'), `
+        mission SyncInvoices {
+          source Xero {
+            auth: oauth2,
+            base: "https://api.xero.com"
+          }
+
+          store invoices: memory("invoices")
+          store details: memory("invoice_details")
+
+          run FetchList then Hydrate
+        }
+      `);
+            // Action files
+            await writeFile(join(missionDir, 'fetch-list.reqon'), `
+        action FetchList {
+          fetch GET "/invoices" { source: Xero }
+          store response -> invoices
+        }
+      `);
+            await writeFile(join(missionDir, 'hydrate.reqon'), `
+        action Hydrate {
+          for invoice in invoices {
+            fetch GET "/invoices/{invoice.id}" { source: Xero }
+            store response -> details
+          }
+        }
+      `);
+            const result = await loadMission(missionDir);
+            expect(result.sourceFiles).toHaveLength(3);
+            expect(result.baseDir).toContain('sync-invoices');
+            const mission = result.program.statements.find(s => s.type === 'MissionDefinition');
+            expect(mission).toBeDefined();
+            expect(mission.name).toBe('SyncInvoices');
+            expect(mission.actions).toHaveLength(2);
+            const actionNames = mission.actions.map((a) => a.name);
+            expect(actionNames).toContain('FetchList');
+            expect(actionNames).toContain('Hydrate');
+        });
+        it('errors if mission.reqon is missing from folder', async () => {
+            const missionDir = join(TEST_DIR, 'no-root');
+            await mkdir(missionDir, { recursive: true });
+            await writeFile(join(missionDir, 'action.reqon'), `
+        action SomeAction {
+          fetch GET "/test" { source: Api }
+        }
+      `);
+            await expect(loadMission(missionDir)).rejects.toThrow(/must contain a root file/);
+        });
+        it('errors if action file contains a mission definition', async () => {
+            const missionDir = join(TEST_DIR, 'bad-action');
+            await mkdir(missionDir, { recursive: true });
+            await writeFile(join(missionDir, 'mission.reqon'), `
+        mission Main {
+          source Api { auth: none, base: "https://api.example.com" }
+          store data: memory("data")
+          run Fetch
+        }
+      `);
+            await writeFile(join(missionDir, 'nested.reqon'), `
+        mission NestedMission {
+          source Api { auth: none, base: "https://other.com" }
+          store data: memory("data")
+          run Something
+        }
+      `);
+            await expect(loadMission(missionDir)).rejects.toThrow(/should not contain a mission definition/);
+        });
+        it('errors on duplicate action names', async () => {
+            const missionDir = join(TEST_DIR, 'duplicate');
+            await mkdir(missionDir, { recursive: true });
+            await writeFile(join(missionDir, 'mission.reqon'), `
+        mission Main {
+          source Api { auth: none, base: "https://api.example.com" }
+          store data: memory("data")
+
+          action Fetch {
+            fetch GET "/a" { source: Api }
+          }
+
+          run Fetch
+        }
+      `);
+            await writeFile(join(missionDir, 'fetch.reqon'), `
+        action Fetch {
+          fetch GET "/b" { source: Api }
+        }
+      `);
+            await expect(loadMission(missionDir)).rejects.toThrow(/Duplicate action definition: 'Fetch'/);
+        });
+        it('errors if pipeline references unknown action', async () => {
+            const missionDir = join(TEST_DIR, 'unknown-action');
+            await mkdir(missionDir, { recursive: true });
+            await writeFile(join(missionDir, 'mission.reqon'), `
+        mission Main {
+          source Api { auth: none, base: "https://api.example.com" }
+          store data: memory("data")
+
+          action Fetch {
+            fetch GET "/items" { source: Api }
+          }
+
+          run Fetch then NonExistent
+        }
+      `);
+            await expect(loadMission(missionDir)).rejects.toThrow(/Pipeline references unknown action: 'NonExistent'/);
+        });
+        it('supports inline actions alongside external files', async () => {
+            const missionDir = join(TEST_DIR, 'mixed');
+            await mkdir(missionDir, { recursive: true });
+            await writeFile(join(missionDir, 'mission.reqon'), `
+        mission Mixed {
+          source Api { auth: none, base: "https://api.example.com" }
+          store data: memory("data")
+
+          action InlineAction {
+            fetch GET "/inline" { source: Api }
+          }
+
+          run InlineAction then ExternalAction
+        }
+      `);
+            await writeFile(join(missionDir, 'external.reqon'), `
+        action ExternalAction {
+          fetch GET "/external" { source: Api }
+          store response -> data
+        }
+      `);
+            const result = await loadMission(missionDir);
+            const mission = result.program.statements.find(s => s.type === 'MissionDefinition');
+            expect(mission.actions).toHaveLength(2);
+        });
+    });
+    describe('isMissionFolder', () => {
+        it('returns true for folder with mission.reqon', async () => {
+            const missionDir = join(TEST_DIR, 'valid-folder');
+            await mkdir(missionDir, { recursive: true });
+            await writeFile(join(missionDir, 'mission.reqon'), 'mission X { run A }');
+            expect(await isMissionFolder(missionDir)).toBe(true);
+        });
+        it('returns true for folder with mission.vague', async () => {
+            const missionDir = join(TEST_DIR, 'vague-folder');
+            await mkdir(missionDir, { recursive: true });
+            await writeFile(join(missionDir, 'mission.vague'), 'mission X { run A }');
+            expect(await isMissionFolder(missionDir)).toBe(true);
+        });
+        it('returns false for folder without mission.reqon', async () => {
+            const missionDir = join(TEST_DIR, 'invalid-folder');
+            await mkdir(missionDir, { recursive: true });
+            expect(await isMissionFolder(missionDir)).toBe(false);
+        });
+        it('returns false for a file', async () => {
+            const filePath = join(TEST_DIR, 'file.reqon');
+            await writeFile(filePath, 'mission X { run A }');
+            expect(await isMissionFolder(filePath)).toBe(false);
+        });
+    });
+    describe('getMissionName', () => {
+        it('extracts name from folder path', () => {
+            expect(getMissionName('/path/to/sync-invoices')).toBe('sync-invoices');
+        });
+        it('extracts name from .reqon file path', () => {
+            expect(getMissionName('/path/to/sync-invoices.reqon')).toBe('sync-invoices');
+        });
+        it('extracts name from .vague file path', () => {
+            expect(getMissionName('/path/to/sync-invoices.vague')).toBe('sync-invoices');
+        });
+    });
+    describe('.vague file priority', () => {
+        it('prefers .vague over .reqon in folder mode', async () => {
+            const missionDir = join(TEST_DIR, 'both-extensions');
+            await mkdir(missionDir, { recursive: true });
+            // Create both files - .vague should be preferred
+            await writeFile(join(missionDir, 'mission.vague'), `
+        mission FromVague {
+          source Api { auth: none, base: "https://api.example.com" }
+          store data: memory("data")
+          action Fetch { fetch GET "/vague" { source: Api } }
+          run Fetch
+        }
+      `);
+            await writeFile(join(missionDir, 'mission.reqon'), `
+        mission FromReqon {
+          source Api { auth: none, base: "https://api.example.com" }
+          store data: memory("data")
+          action Fetch { fetch GET "/reqon" { source: Api } }
+          run Fetch
+        }
+      `);
+            const result = await loadMission(missionDir);
+            const mission = result.program.statements.find(s => s.type === 'MissionDefinition');
+            expect(mission.name).toBe('FromVague');
+        });
+        it('loads folder with mission.vague and .vague action files', async () => {
+            const missionDir = join(TEST_DIR, 'vague-folder-mode');
+            await mkdir(missionDir, { recursive: true });
+            await writeFile(join(missionDir, 'mission.vague'), `
+        mission VagueMode {
+          source Api { auth: none, base: "https://api.example.com" }
+          store data: memory("data")
+          run Fetch
+        }
+      `);
+            await writeFile(join(missionDir, 'fetch.vague'), `
+        action Fetch {
+          fetch GET "/items" { source: Api }
+        }
+      `);
+            const result = await loadMission(missionDir);
+            expect(result.sourceFiles).toHaveLength(2);
+            expect(result.sourceFiles[0]).toContain('mission.vague');
+            expect(result.sourceFiles[1]).toContain('fetch.vague');
+        });
+    });
+});