eventmodeler 0.4.4 → 0.4.6

package/dist/slices/add-scenario/index.js

@@ -1,6 +1,17 @@
-import * as crypto from 'node:crypto';
-import { appendEvent } from '../../lib/file-loader.js';
-import { findElementOrExit, excludeLinkedCopies } from '../../lib/element-lookup.js';
+import { XMLParser } from 'fast-xml-parser';
+const xmlParser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '@_',
+    allowBooleanAttributes: false,
+    parseAttributeValue: false,
+    isArray: (name) => name === 'event' || name === 'field',
+    trimValues: true,
+});
+function asArray(value) {
+    if (value === undefined || value === null)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
 function asRecord(value, context) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         throw new Error(`${context} must be an object`);
@@ -28,91 +39,62 @@ function parseFieldValue(value) {
         return trimmed;
     }
 }
-function stripTags(value) {
-    return value.replace(/<[^>]*>/g, '');
-}
-function getAttr(attrs, attr) {
-    const match = attrs.match(new RegExp(`${attr}="([^"]*)"`, 'i'));
-    return match ? match[1] : undefined;
-}
-function extractTopLevelTagBlocks(xml, tagName) {
-    const blocks = [];
-    const regex = new RegExp(`<\\/?${tagName}\\b[^>]*>`, 'gi');
-    let match;
-    let depth = 0;
-    let startIndex = -1;
-    let startTagEnd = -1;
-    let startAttrs = '';
-    while ((match = regex.exec(xml)) !== null) {
-        const token = match[0];
-        const isClosing = /^<\//.test(token);
-        if (!isClosing) {
-            const selfClosing = /\/>$/.test(token.trim());
-            if (depth === 0) {
-                startIndex = match.index;
-                startTagEnd = match.index + token.length;
-                startAttrs = token.slice(tagName.length + 1, token.length - (selfClosing ? 2 : 1)).trim();
-                if (selfClosing) {
-                    blocks.push({ attrs: startAttrs, inner: '', selfClosing: true });
-                    startIndex = -1;
-                }
-                else {
-                    depth = 1;
-                }
+function parseFieldValuesFromNodes(nodes) {
+    if (nodes.length === 0)
+        return undefined;
+    const result = {};
+    for (const node of nodes) {
+        const n = node;
+        const name = n['@_name'];
+        if (!name)
+            continue;
+        const childFields = asArray(n['field']);
+        let value;
+        if (childFields.length > 0) {
+            value = parseFieldValuesFromNodes(childFields);
+        }
+        else {
+            // Get text content (fast-xml-parser stores it as #text)
+            const text = n['#text'];
+            if (text === undefined || text === '') {
+                value = null;
             }
-            else if (!selfClosing) {
-                depth++;
+            else {
+                value = parseFieldValue(String(text));
             }
-            continue;
         }
-        if (depth === 0)
-            continue;
-        depth--;
-        if (depth === 0 && startIndex >= 0) {
-            blocks.push({
-                attrs: startAttrs,
-                inner: xml.slice(startTagEnd, match.index),
-                selfClosing: false,
-            });
-            startIndex = -1;
+        // Handle duplicate keys (multiple values → array)
+        if (name in result) {
+            const current = result[name];
+            if (Array.isArray(current)) {
+                current.push(value);
+            }
+            else {
+                result[name] = [current, value];
+            }
+        }
+        else {
+            result[name] = value;
         }
     }
-    return blocks;
-}
-function firstTagBlock(xml, tagName) {
-    return extractTopLevelTagBlocks(xml, tagName)[0];
-}
-function assignFieldValue(target, key, value) {
-    if (!(key in target)) {
-        target[key] = value;
-        return;
-    }
-    const current = target[key];
-    if (Array.isArray(current)) {
-        current.push(value);
-    }
-    else {
-        target[key] = [current, value];
-    }
+    return Object.keys(result).length > 0 ? result : undefined;
 }
-function parseFieldValuesFromXml(xml) {
-    const fields = extractTopLevelTagBlocks(xml, 'field');
-    if (fields.length === 0)
-        return undefined;
-    const result = {};
-    for (const field of fields) {
-        const name = getAttr(field.attrs, 'name');
-        if (!name)
+function parseEventInputsFromNodes(nodes) {
+    const result = [];
+    for (const node of nodes) {
+        const n = node;
+        const nameFromAttr = n['@_name'];
+        const textContent = n['#text'];
+        const eventName = nameFromAttr ?? textContent;
+        if (!eventName)
             continue;
-        const nestedValues = parseFieldValuesFromXml(field.inner);
-        const value = nestedValues && Object.keys(nestedValues).length > 0
-            ? nestedValues
-            : field.selfClosing
-                ? null
-                : parseFieldValue(stripTags(field.inner));
-        assignFieldValue(result, name, value);
+        const childFields = asArray(n['field']);
+        result.push({
+            event: eventName,
+            fieldValues: parseFieldValuesFromNodes(childFields),
+        });
     }
-    return Object.keys(result).length > 0 ? result : undefined;
+    return result;
 }
 function parseEventInput(value, context) {
     if (typeof value === 'string') {
@@ -214,55 +196,49 @@ function normalizeScenarioInput(rawValue) {
 function parseJsonInput(input) {
     return normalizeScenarioInput(JSON.parse(input));
 }
-function parseEventInputsFromXml(xml) {
-    const result = [];
-    const eventBlocks = extractTopLevelTagBlocks(xml, 'event');
-    for (const eventBlock of eventBlocks) {
-        const nameFromAttr = getAttr(eventBlock.attrs, 'name');
-        const nameFromContent = eventBlock.inner.split('<', 1)[0].trim();
-        const eventName = nameFromAttr ?? nameFromContent;
-        if (!eventName)
-            continue;
-        result.push({
-            event: eventName,
-            fieldValues: parseFieldValuesFromXml(eventBlock.inner),
-        });
-    }
-    return result;
-}
 function parseXmlInput(input) {
-    const scenarioMatch = input.match(/<scenario([^>]*)>/);
-    if (!scenarioMatch) {
+    const parsed = xmlParser.parse(input);
+    const scenario = parsed['scenario'];
+    if (!scenario) {
         throw new Error('Invalid XML: missing <scenario> tag');
     }
-    const name = getAttr(scenarioMatch[1], 'name');
+    const name = scenario['@_name'];
     if (!name) {
         throw new Error('Invalid XML: scenario must have a name attribute');
     }
-    const description = getAttr(scenarioMatch[1], 'description');
-    const givenBlock = firstTagBlock(input, 'given');
-    const given = givenBlock ? parseEventInputsFromXml(givenBlock.inner) : [];
+    const description = scenario['@_description'];
+    // Parse given events
+    const givenNode = scenario['given'];
+    const given = givenNode ? parseEventInputsFromNodes(asArray(givenNode['event'])) : [];
+    // Parse when
     let when;
-    const whenBlock = firstTagBlock(input, 'when');
-    if (whenBlock) {
-        const commandBlock = firstTagBlock(whenBlock.inner, 'command');
-        const whenEvents = parseEventInputsFromXml(whenBlock.inner);
-        if (commandBlock || whenEvents.length > 0) {
-            const commandName = commandBlock
-                ? getAttr(commandBlock.attrs, 'name') ?? commandBlock.inner.split('<', 1)[0].trim()
-                : undefined;
+    const whenNode = scenario['when'];
+    if (whenNode) {
+        const commandNodes = asArray(whenNode['command']);
+        const commandNode = commandNodes[0];
+        const whenEvents = parseEventInputsFromNodes(asArray(whenNode['event']));
+        if (commandNode || whenEvents.length > 0) {
+            let commandName;
+            let commandFieldValues;
+            if (commandNode) {
+                const nameFromAttr = commandNode['@_name'];
+                const textContent = commandNode['#text'];
+                commandName = nameFromAttr ?? textContent ?? undefined;
+                commandFieldValues = parseFieldValuesFromNodes(asArray(commandNode['field']));
+            }
             when = {
                 command: commandName || undefined,
-                commandFieldValues: commandBlock ? parseFieldValuesFromXml(commandBlock.inner) : undefined,
+                commandFieldValues,
                 events: whenEvents.length > 0 ? whenEvents : undefined,
             };
         }
     }
-    const thenMatch = input.match(/<then([^>]*?)(?:\/>|>([\s\S]*?)<\/then>)/);
-    if (!thenMatch) {
+    // Parse then
+    const thenNode = scenario['then'];
+    if (!thenNode) {
         throw new Error('Invalid XML: missing <then> tag');
     }
-    const thenType = getAttr(thenMatch[1], 'type');
+    const thenType = thenNode['@_type'];
     if (thenType !== 'error' &&
         thenType !== 'events' &&
         thenType !== 'readModelAssertion' &&
@@ -270,37 +246,47 @@ function parseXmlInput(input) {
         thenType !== 'noCommand') {
         throw new Error('Invalid XML: <then> must have a type attribute');
     }
-    const thenBody = thenMatch[2] ?? '';
     const then = { type: thenType };
     if (thenType === 'error') {
-        then.errorType = getAttr(thenMatch[1], 'errorType') ?? firstTagBlock(thenBody, 'errorType')?.inner.trim();
-        then.errorMessage = firstTagBlock(thenBody, 'message')?.inner.trim() ?? stripTags(thenBody).trim();
+        then.errorType = thenNode['@_errorType'];
+        const errorTypeNode = thenNode['errorType'];
+        if (!then.errorType && errorTypeNode) {
+            then.errorType = typeof errorTypeNode === 'string' ? errorTypeNode : errorTypeNode['#text'];
+        }
+        const messageNode = thenNode['message'];
+        if (messageNode) {
+            then.errorMessage = typeof messageNode === 'string' ? messageNode : messageNode['#text'];
+        }
     }
     else if (thenType === 'events') {
-        then.events = parseEventInputsFromXml(thenBody);
+        then.events = parseEventInputsFromNodes(asArray(thenNode['event']));
     }
     else if (thenType === 'command') {
-        const commandBlock = firstTagBlock(thenBody, 'command');
-        if (commandBlock) {
-            then.command = getAttr(commandBlock.attrs, 'name') ?? commandBlock.inner.split('<', 1)[0].trim();
-            then.commandFieldValues = parseFieldValuesFromXml(commandBlock.inner);
+        const commandNodes = asArray(thenNode['command']);
+        const commandNode = commandNodes[0];
+        if (commandNode) {
+            const nameFromAttr = commandNode['@_name'];
+            const textContent = commandNode['#text'];
+            then.command = nameFromAttr ?? textContent ?? undefined;
+            then.commandFieldValues = parseFieldValuesFromNodes(asArray(commandNode['field']));
         }
     }
     else if (thenType === 'readModelAssertion') {
-        const readModelBlock = firstTagBlock(thenBody, 'read-model');
-        if (readModelBlock) {
-            then.readModel = getAttr(readModelBlock.attrs, 'name') ?? readModelBlock.inner.split('<', 1)[0].trim();
-            const expectedBlock = firstTagBlock(readModelBlock.inner, 'expected');
-            const directExpected = parseFieldValuesFromXml(readModelBlock.inner);
-            const expectedFromBlock = expectedBlock ? parseFieldValuesFromXml(expectedBlock.inner) : undefined;
+        const readModelNode = thenNode['read-model'];
+        if (readModelNode) {
+            const nameFromAttr = readModelNode['@_name'];
+            const textContent = readModelNode['#text'];
+            then.readModel = nameFromAttr ?? textContent ?? undefined;
+            const expectedNode = readModelNode['expected'];
+            const directFields = parseFieldValuesFromNodes(asArray(readModelNode['field']));
+            const expectedFields = expectedNode ? parseFieldValuesFromNodes(asArray(expectedNode['field'])) : undefined;
             then.expected = {
-                ...(directExpected ?? {}),
-                ...(expectedFromBlock ?? {}),
+                ...(directFields ?? {}),
+                ...(expectedFields ?? {}),
             };
-            const givenBlockInAssertion = firstTagBlock(readModelBlock.inner, 'given')
-                ?? firstTagBlock(readModelBlock.inner, 'given-events');
-            if (givenBlockInAssertion) {
-                then.givenEvents = parseEventInputsFromXml(givenBlockInAssertion.inner);
+            const givenEventsNode = (readModelNode['given'] ?? readModelNode['given-events']);
+            if (givenEventsNode) {
+                then.givenEvents = parseEventInputsFromNodes(asArray(givenEventsNode['event']));
             }
         }
     }
@@ -319,187 +305,3 @@ export function parseScenarioInput(input) {
     }
     return parseJsonInput(trimmed);
 }
-export function addScenario(model, filePath, sliceName, input) {
-    // Parse input
-    let scenarioInput;
-    try {
-        scenarioInput = parseScenarioInput(input);
-    }
-    catch (err) {
-        console.error(`Error: Invalid input format: ${err.message}`);
-        process.exit(1);
-    }
-    // Find slice by name
-    const slice = findElementOrExit(model.slices, sliceName, 'slice');
-    // Resolve event references in given (exclude linked copies)
-    const givenEvents = [];
-    if (scenarioInput.given) {
-        for (const g of scenarioInput.given) {
-            const event = findElementOrExit(excludeLinkedCopies(model.events), g.event, 'event');
-            givenEvents.push({
-                eventStickyId: event.id,
-                fieldValues: g.fieldValues,
-            });
-        }
-    }
-    // Resolve command reference in when
-    let whenCommand = null;
-    if (scenarioInput.when?.command) {
-        const command = findElementOrExit(model.commands, scenarioInput.when.command, 'command');
-        whenCommand = {
-            commandStickyId: command.id,
-            fieldValues: scenarioInput.when.commandFieldValues,
-        };
-    }
-    // Resolve event references in when
-    const whenEvents = [];
-    if (scenarioInput.when?.events) {
-        for (const e of scenarioInput.when.events) {
-            const event = findElementOrExit(excludeLinkedCopies(model.events), e.event, 'event');
-            whenEvents.push({
-                eventStickyId: event.id,
-                fieldValues: e.fieldValues,
-            });
-        }
-    }
-    // Resolve then clause
-    const then = { type: scenarioInput.then.type };
-    if (scenarioInput.then.type === 'error') {
-        then.errorMessage = scenarioInput.then.errorMessage;
-        then.errorType = scenarioInput.then.errorType;
-    }
-    else if (scenarioInput.then.type === 'events') {
-        then.expectedEvents = [];
-        if (scenarioInput.then.events) {
-            for (const e of scenarioInput.then.events) {
-                const event = findElementOrExit(excludeLinkedCopies(model.events), e.event, 'event');
-                then.expectedEvents.push({
-                    eventStickyId: event.id,
-                    fieldValues: e.fieldValues,
-                });
-            }
-        }
-    }
-    else if (scenarioInput.then.type === 'command') {
-        if (!scenarioInput.then.command) {
-            console.error('Error: command then type requires a command name');
-            process.exit(1);
-        }
-        const command = findElementOrExit(model.commands, scenarioInput.then.command, 'command');
-        then.expectedCommand = {
-            commandStickyId: command.id,
-            fieldValues: scenarioInput.then.commandFieldValues,
-        };
-    }
-    else if (scenarioInput.then.type === 'readModelAssertion') {
-        if (!scenarioInput.then.readModel) {
-            console.error('Error: readModelAssertion requires a readModel name');
-            process.exit(1);
-        }
-        const readModel = findElementOrExit(excludeLinkedCopies(model.readModels), scenarioInput.then.readModel, 'read model');
-        const assertionGivenEvents = [];
-        if (scenarioInput.then.givenEvents) {
-            for (const g of scenarioInput.then.givenEvents) {
-                const event = findElementOrExit(excludeLinkedCopies(model.events), g.event, 'event');
-                assertionGivenEvents.push({
-                    eventStickyId: event.id,
-                    fieldValues: g.fieldValues,
-                });
-            }
-        }
-        then.readModelAssertion = {
-            readModelStickyId: readModel.id,
-            givenEvents: assertionGivenEvents,
-            expectedFieldValues: scenarioInput.then.expected ?? {},
-        };
-    }
-    // Calculate position below slice
-    // Scenarios are tall (GWT rows with 100px stickies + labels + padding = ~400px+)
-    // so we need adequate spacing between them
-    const SCENARIO_GAP = 20; // Match slice gap
-    const SCENARIO_ESTIMATED_HEIGHT = 450; // Approximate rendered height for positioning
-    const existingScenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
-    const sliceBottom = slice.position.y + slice.size.height;
-    let positionY;
-    if (existingScenarios.length === 0) {
-        positionY = sliceBottom + SCENARIO_GAP;
-    }
-    else {
-        // Use estimated height since stored height (80px) doesn't reflect actual rendered size
-        const lowestY = Math.max(...existingScenarios.map(s => s.position.y + SCENARIO_ESTIMATED_HEIGHT));
-        positionY = lowestY + SCENARIO_GAP;
-    }
-    const position = {
-        x: slice.position.x + 10,
-        y: positionY,
-    };
-    // Generate scenario ID
-    const scenarioId = crypto.randomUUID();
-    // Append ScenarioCreated event
-    appendEvent(filePath, {
-        type: 'ScenarioCreated',
-        data: {
-            scenarioId,
-            sliceId: slice.id,
-            name: scenarioInput.name,
-            position,
-            width: 200,
-            height: 80,
-            timestamp: Date.now(),
-        },
-    });
-    // Append description update if provided
-    if (scenarioInput.description) {
-        appendEvent(filePath, {
-            type: 'ScenarioDescriptionUpdated',
-            data: {
-                scenarioId,
-                description: scenarioInput.description,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    // Append given events update if provided
-    if (givenEvents.length > 0) {
-        appendEvent(filePath, {
-            type: 'ScenarioGivenEventsUpdated',
-            data: {
-                scenarioId,
-                givenEvents,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    // Append when command update if provided
-    if (whenCommand) {
-        appendEvent(filePath, {
-            type: 'ScenarioWhenCommandUpdated',
-            data: {
-                scenarioId,
-                whenCommand,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    // Append when events update if provided
-    if (whenEvents.length > 0) {
-        appendEvent(filePath, {
-            type: 'ScenarioWhenEventsUpdated',
-            data: {
-                scenarioId,
-                whenEvents,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    // Append then update
-    appendEvent(filePath, {
-        type: 'ScenarioThenUpdated',
-        data: {
-            scenarioId,
-            then,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Added scenario "${scenarioInput.name}" to slice "${slice.name}"`);
-}

package/dist/slices/init/index.d.ts

@@ -1,4 +1,5 @@
 /**
  * Interactive init command to set up a project.
+ * Connects the current directory to an event model.
  */
 export declare function init(): Promise<void>;

package/dist/slices/init/index.js

@@ -1,14 +1,12 @@
 import * as readline from 'node:readline';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
 import { isAuthenticated } from '../../lib/config.js';
-import { createCloudClient } from '../../lib/cloud-client.js';
+import { listModels } from '../../api/index.js';
 import { saveProjectConfig, getProjectRoot, isInProject } from '../../lib/project-config.js';
 /**
  * Interactive init command to set up a project.
+ * Connects the current directory to an event model.
  */
 export async function init() {
-    // Check if already initialized
     if (isInProject()) {
         console.log('This project is already initialized.');
         console.log('To reconfigure, delete .eventmodeler.json and run init again.');
@@ -16,6 +14,11 @@ export async function init() {
     }
     const projectRoot = getProjectRoot();
     console.log(`Initializing event model project in: ${projectRoot}\n`);
+    if (!isAuthenticated()) {
+        console.log('You need to be logged in first.');
+        console.log('Run "eventmodeler login" first, then try init again.');
+        return;
+    }
     const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
@@ -28,22 +31,46 @@ export async function init() {
         });
     };
     try {
-        // Ask what type of backend
-        console.log('How would you like to store your event model?\n');
-        console.log('  1. Cloud (recommended) - Store in eventmodeler.app cloud');
-        console.log('  2. Local file - Store in a .eventmodel file\n');
-        const choice = await question('Enter choice (1 or 2): ');
-        if (choice === '1') {
-            await initCloud(question, projectRoot);
+        console.log('Fetching your event models...\n');
+        const models = await listModels();
+        if (models.length === 0) {
+            console.log('You don\'t have any event models yet.');
+            console.log('Create one at https://eventmodeler.app first, then run init again.');
+            rl.close();
+            return;
+        }
+        console.log('Your event models:\n');
+        models.forEach((model, index) => {
+            console.log(`  ${index + 1}. ${model.name} (${model.modelId})`);
+        });
+        console.log(`  ${models.length + 1}. Create a new model\n`);
+        const modelChoice = await question(`Select a model (1-${models.length + 1}): `);
+        const modelIndex = parseInt(modelChoice, 10) - 1;
+        let selectedModel;
+        if (modelIndex === models.length) {
+            console.log('\nTo create a new model, visit https://eventmodeler.app');
+            console.log('After creating it, run init again to link it to this project.');
+            rl.close();
+            return;
         }
-        else if (choice === '2') {
-            await initLocal(question, projectRoot);
+        else if (modelIndex >= 0 && modelIndex < models.length) {
+            selectedModel = models[modelIndex];
         }
         else {
             console.log('\nInvalid choice. Please run init again.');
             rl.close();
             return;
         }
+        const config = {
+            type: 'cloud',
+            modelId: selectedModel.modelId,
+            modelName: selectedModel.name,
+        };
+        const configPath = saveProjectConfig(config, projectRoot);
+        console.log(`\nProject initialized successfully!`);
+        console.log(`Config saved to: ${configPath}`);
+        console.log(`\nLinked to model: ${selectedModel.name}`);
+        console.log('\nYou can now use eventmodeler commands in this directory.');
         rl.close();
     }
     catch (err) {
@@ -51,83 +78,3 @@ export async function init() {
         throw err;
     }
 }
-async function initCloud(question, projectRoot) {
-    // Check authentication
-    if (!isAuthenticated()) {
-        console.log('\nYou need to be logged in to use cloud storage.');
-        console.log('Run "eventmodeler login" first, then try init again.');
-        return;
-    }
-    console.log('\nFetching your event models...\n');
-    const client = await createCloudClient();
-    const models = await client.listModels();
-    if (models.length === 0) {
-        console.log('You don\'t have any event models yet.');
-        console.log('Create one at https://eventmodeler.app first, then run init again.');
-        return;
-    }
-    console.log('Your event models:\n');
-    models.forEach((model, index) => {
-        console.log(`  ${index + 1}. ${model.name} (${model.modelId})`);
-    });
-    console.log(`  ${models.length + 1}. Create a new model\n`);
-    const modelChoice = await question(`Select a model (1-${models.length + 1}): `);
-    const modelIndex = parseInt(modelChoice, 10) - 1;
-    let selectedModel;
-    if (modelIndex === models.length) {
-        // Create new model - for now, redirect to web
-        console.log('\nTo create a new model, visit https://eventmodeler.app');
-        console.log('After creating it, run init again to link it to this project.');
-        return;
-    }
-    else if (modelIndex >= 0 && modelIndex < models.length) {
-        selectedModel = models[modelIndex];
-    }
-    else {
-        console.log('\nInvalid choice. Please run init again.');
-        return;
-    }
-    const config = {
-        type: 'cloud',
-        modelId: selectedModel.modelId,
-        modelName: selectedModel.name,
-    };
-    const configPath = saveProjectConfig(config, projectRoot);
-    console.log(`\nProject initialized successfully!`);
-    console.log(`Config saved to: ${configPath}`);
-    console.log(`\nLinked to cloud model: ${selectedModel.name}`);
-    console.log('\nYou can now use eventmodeler commands in this directory.');
-}
-async function initLocal(question, projectRoot) {
-    const defaultFile = './model.eventmodel';
-    const filePath = await question(`Event model file path [${defaultFile}]: `);
-    const finalPath = filePath || defaultFile;
-    // Resolve relative to project root
-    const absolutePath = path.isAbsolute(finalPath)
-        ? finalPath
-        : path.resolve(projectRoot, finalPath);
-    // Check if file exists, create if not
-    if (!fs.existsSync(absolutePath)) {
-        const create = await question(`File doesn't exist. Create it? (y/n): `);
-        if (create.toLowerCase() === 'y') {
-            // Create empty event model file
-            fs.writeFileSync(absolutePath, '');
-            console.log(`\nCreated: ${absolutePath}`);
-        }
-        else {
-            console.log('\nAborted. Please create the file and run init again.');
-            return;
-        }
-    }
-    // Store relative path in config
-    const relativePath = path.relative(projectRoot, absolutePath);
-    const config = {
-        type: 'local',
-        file: relativePath.startsWith('.') ? relativePath : `./${relativePath}`,
-    };
-    const configPath = saveProjectConfig(config, projectRoot);
-    console.log(`\nProject initialized successfully!`);
-    console.log(`Config saved to: ${configPath}`);
-    console.log(`\nLinked to local file: ${config.file}`);
-    console.log('\nYou can now use eventmodeler commands in this directory.');
-}