harmonyc 0.18.1 → 0.20.0

package/{code_generator → dist/code_generator}/VitestGenerator.d.ts

@@ -1,14 +1,17 @@
-import { Action, CodeGenerator, ErrorResponse, Feature, Phrase, Response, SaveToVariable, SetVariable, Test, TestGroup } from '../model/model.ts';
+import { CompilerOptions } from '../compiler/compile.ts';
+import { Action, CodeGenerator, ErrorResponse, Feature, Phrase, PhraseMethod, Response, SaveToVariable, SetVariable, Test, TestGroup } from '../model/model.ts';
 import { OutFile } from './outFile.ts';
 export declare class VitestGenerator implements CodeGenerator {
     private tf;
-    private sf;
-    private _sourceFileName;
+    private sourceFileName;
+    private opts;
     static error(message: string, stack: string): string;
     framework: string;
     phraseFns: Map<string, Phrase>;
     currentFeatureName: string;
-    constructor(tf: OutFile, sf: OutFile, _sourceFileName: string);
+    featureClassName: string;
+    phraseMethods: PhraseMethod[];
+    constructor(tf: OutFile, sourceFileName: string, opts: CompilerOptions);
     feature(feature: Feature): void;
     testGroup(g: TestGroup): void;
     featureVars: Map<string, string>;
@@ -28,5 +31,6 @@ export declare class VitestGenerator implements CodeGenerator {
     private paramName;
     stringParamDeclaration(index: number): string;
     variantParamDeclaration(index: number): string;
+    functionName(phrase: Phrase): string;
+    argPlaceholder(i: number): string;
 }
-export declare function functionName(phrase: Phrase): string;

package/{code_generator → dist/code_generator}/VitestGenerator.js

@@ -1,5 +1,8 @@
 import { basename } from 'path';
+import { xyzab } from "../compiler/compile.js";
 import { Arg, Response, Word, } from "../model/model.js";
+const X = 'X'.codePointAt(0);
+const A = 'A'.codePointAt(0);
 export class VitestGenerator {
     static error(message, stack) {
         return `const e = new SyntaxError(${str(message)});
@@ -7,19 +10,22 @@ export class VitestGenerator {
     throw e;
     ${stack ? `/* ${stack} */` : ''}`;
     }
-    constructor(tf, sf, _sourceFileName) {
+    constructor(tf, sourceFileName, opts) {
         this.tf = tf;
-        this.sf = sf;
-        this._sourceFileName = _sourceFileName;
+        this.sourceFileName = sourceFileName;
+        this.opts = opts;
         this.framework = 'vitest';
         this.phraseFns = new Map();
         this.currentFeatureName = '';
+        this.phraseMethods = [];
         this.resultCount = 0;
         this.extraArgs = [];
     }
     feature(feature) {
-        const phrasesModule = './' + basename(this.sf.name.replace(/.(js|ts)$/, ''));
-        const fn = (this.currentFeatureName = pascalCase(feature.name));
+        const phrasesModule = './' + basename(this.sourceFileName.replace(/\.harmony$/, '.phrases.js'));
+        const fn = (this.featureClassName =
+            this.currentFeatureName =
+                pascalCase(feature.name) + 'Phrases');
         this.phraseFns = new Map();
         // test file
         if (this.framework === 'vitest') {
@@ -30,26 +36,33 @@ export class VitestGenerator {
             this.tf.print(`describe.todo(${str(feature.name)});`);
             return;
         }
-        this.tf.print(`import ${fn}Phrases from ${str(phrasesModule)};`);
+        this.tf.print(`import ${fn} from ${str(phrasesModule)};`);
         this.tf.print(``);
         for (const item of feature.testGroups) {
             item.toCode(this);
         }
         this.tf.print(``);
-        // phrases file
-        this.sf.print(`export default class ${pascalCase(feature.name)}Phrases {`);
-        this.sf.indent(() => {
-            for (const ph of this.phraseFns.keys()) {
-                const p = this.phraseFns.get(ph);
-                const params = p.args.map((a, i) => a.toDeclaration(this, i)).join(', ');
-                this.sf.print(`async ${ph}(${params}) {`);
-                this.sf.indent(() => {
-                    this.sf.print(`throw new Error(${str(`Pending: ${ph}`)});`);
+        for (const ph of this.phraseFns.keys()) {
+            const p = this.phraseFns.get(ph);
+            const parameters = p.args.map((a, i) => {
+                const declaration = a.toDeclaration(this, i);
+                const parts = declaration.split(': ');
+                return {
+                    name: parts[0],
+                    type: parts[1] || 'any',
+                };
+            });
+            if (p instanceof Response) {
+                parameters.push({
+                    name: 'res',
+                    type: 'any',
                 });
-                this.sf.print(`}`);
             }
-        });
-        this.sf.print(`};`);
+            this.phraseMethods.push({
+                name: ph,
+                parameters,
+            });
+        }
     }
     testGroup(g) {
         this.tf.print(`describe(${str(g.label.text)}, () => {`, g.label.start, g.label.text);
@@ -124,7 +137,7 @@ export class VitestGenerator {
         }
     }
     phrase(p) {
-        const phrasefn = functionName(p);
+        const phrasefn = this.functionName(p);
         if (!this.phraseFns.has(phrasefn))
             this.phraseFns.set(phrasefn, p);
         const f = this.featureVars.get(p.feature.name);
@@ -139,7 +152,7 @@ export class VitestGenerator {
             this.saveToVariable(p.saveToVariable, '');
         }
         this.tf.printn(`await ${f}.`);
-        this.tf.write(`${functionName(p)}(${args.join(', ')})`, p.start, name);
+        this.tf.write(`${phrasefn}(${args.join(', ')})`, p.start, name);
         this.tf.write(`);`);
         this.tf.nl();
     }
@@ -159,7 +172,7 @@ export class VitestGenerator {
         return src.replace(/\$\{([^\s}]+)\}/g, (_, x) => `context.task.meta.variables?.[${str(x)}]`);
     }
     paramName(index) {
-        return 'xyz'.charAt(index) || `a${index + 1}`;
+        return xyzab(index);
     }
     stringParamDeclaration(index) {
         return `${this.paramName(index)}: string`;
@@ -167,6 +180,23 @@ export class VitestGenerator {
     variantParamDeclaration(index) {
         return `${this.paramName(index)}: any`;
     }
+    functionName(phrase) {
+        const { kind } = phrase;
+        let argIndex = -1;
+        return ((kind === 'response' ? 'Then_' : 'When_') +
+            (phrase.parts
+                .flatMap((c) => c instanceof Word
+                ? words(c.text).filter((x) => x)
+                : c instanceof Arg
+                    ? [this.argPlaceholder(++argIndex)]
+                    : [])
+                .join('_') || ''));
+    }
+    argPlaceholder(i) {
+        return typeof this.opts.argumentPlaceholder === 'function'
+            ? this.opts.argumentPlaceholder(i)
+            : this.opts.argumentPlaceholder;
+    }
 }
 function str(s) {
     if (s.includes('\n'))
@@ -208,14 +238,3 @@ function abbrev(s) {
         .map((x) => x.charAt(0).toUpperCase())
         .join('');
 }
-export function functionName(phrase) {
-    const { kind } = phrase;
-    return ((kind === 'response' ? 'Then_' : 'When_') +
-        (phrase.parts
-            .flatMap((c) => c instanceof Word
-            ? words(c.text).filter((x) => x)
-            : c instanceof Arg
-                ? ['']
-                : [])
-            .join('_') || ''));
-}

package/{code_generator → dist/code_generator}/test_phrases.d.ts

@@ -3,9 +3,9 @@ export declare class TestPhrases {
     constructor(context: any);
     When_goodbye(): void;
     When_hello(): string;
-    When_greet_(name: string): void;
-    Then__is_(x: string, y: string): Promise<void>;
+    When_greet_X(name: string): void;
+    Then_X_is_Y(x: string, y: string): Promise<void>;
     Then_last_char(s: string): string;
     Then_last_char_of_greeting(): any;
-    Then_(s: string, r: string): void;
+    Then_X(s: string, r: string): void;
 }

package/{code_generator → dist/code_generator}/test_phrases.js

@@ -9,10 +9,10 @@ export class TestPhrases {
     When_hello() {
         return (this.context.task.meta.greeting = 'Hello!');
     }
-    When_greet_(name) {
+    When_greet_X(name) {
         this.context.task.meta.greeting = `Hello, ${name}!`;
     }
-    async Then__is_(x, y) {
+    async Then_X_is_Y(x, y) {
         expect(x).toBe(y);
     }
     Then_last_char(s) {
@@ -21,7 +21,7 @@ export class TestPhrases {
     Then_last_char_of_greeting() {
         return this.context.task.meta.greeting.slice(-1);
     }
-    Then_(s, r) {
+    Then_X(s, r) {
         expect(s).toBe(r);
     }
 }

package/dist/compiler/compile.d.ts

@@ -0,0 +1,16 @@
+import { OutFile } from '../code_generator/outFile.ts';
+export interface CompilerOptions {
+    argumentPlaceholder: string | ((index: number) => string);
+}
+export interface CompiledFeature {
+    name: string;
+    code: Record<string, string>;
+}
+export declare function XYZAB(index: number): string;
+export declare function xyzab(index: number): string;
+export declare const DEFAULT_COMPILER_OPTIONS: CompilerOptions;
+export declare function compileFeature(fileName: string, src: string, opts?: Partial<CompilerOptions>): {
+    outFile: OutFile;
+    phraseMethods: import("../model/model.ts").PhraseMethod[];
+    featureClassName: string;
+};

package/{compiler → dist/compiler}/compile.js

@@ -1,11 +1,24 @@
 import { basename } from 'node:path';
 import { VitestGenerator } from "../code_generator/VitestGenerator.js";
 import { OutFile } from "../code_generator/outFile.js";
-import { base, phrasesFileName, testFileName } from "../filenames/filenames.js";
+import { base, testFileName } from "../filenames/filenames.js";
 import { Feature } from "../model/model.js";
 import { autoLabel } from "../optimizations/autoLabel/autoLabel.js";
 import { parse } from "../parser/parser.js";
-export function compileFeature(fileName, src) {
+const X = 'X'.codePointAt(0);
+const A = 'A'.codePointAt(0);
+const x = 'x'.codePointAt(0);
+const a = 'a'.codePointAt(0);
+export function XYZAB(index) {
+    return String.fromCodePoint(A + ((X - A + index) % 26));
+}
+export function xyzab(index) {
+    return String.fromCodePoint(a + ((x - a + index) % 26));
+}
+export const DEFAULT_COMPILER_OPTIONS = {
+    argumentPlaceholder: XYZAB,
+};
+export function compileFeature(fileName, src, opts = {}) {
     const feature = new Feature(basename(base(fileName)));
     try {
         feature.root = parse(src);
@@ -24,9 +37,14 @@ export function compileFeature(fileName, src) {
     autoLabel(feature.root);
     const testFn = testFileName(fileName);
     const testFile = new OutFile(testFn, fileName);
-    const phrasesFn = phrasesFileName(fileName);
-    const phrasesFile = new OutFile(phrasesFn, fileName);
-    const cg = new VitestGenerator(testFile, phrasesFile, fileName);
+    const cg = new VitestGenerator(testFile, fileName, {
+        ...DEFAULT_COMPILER_OPTIONS,
+        ...opts,
+    });
     feature.toCode(cg);
-    return { outFile: testFile, phrasesFile };
+    return {
+        outFile: testFile,
+        phraseMethods: cg.phraseMethods,
+        featureClassName: cg.featureClassName,
+    };
 }

package/{compiler → dist/compiler}/compiler.d.ts

@@ -3,8 +3,6 @@ export declare function compileFiles(pattern: string | string[]): Promise<{
     outFns: string[];
 }>;
 export declare function compileFile(fn: string): Promise<{
-    phrasesFileAction: string;
     outFile: import("../code_generator/outFile.ts").OutFile;
-    phrasesFile: import("../code_generator/outFile.ts").OutFile;
 } | undefined>;
 export declare function preprocess(src: string): string;

package/{compiler → dist/compiler}/compiler.js

@@ -1,8 +1,6 @@
 import glob from 'fast-glob';
-import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { readFileSync, writeFileSync } from 'fs';
 import { resolve } from 'path';
-import { VitestGenerator } from "../code_generator/VitestGenerator.js";
-import { testFileName } from "../filenames/filenames.js";
 import { compileFeature } from "./compile.js";
 export async function compileFiles(pattern) {
     var _a;
@@ -17,29 +15,17 @@ export async function compileFiles(pattern) {
     }
     console.log(`Compiled ${compiled.length} file${compiled.length === 1 ? '' : 's'}.`);
     const features = compiled.filter((f) => f !== undefined);
-    const generated = features.filter((f) => f.phrasesFileAction === 'generated');
-    if (generated.length) {
-        console.log(`Generated ${generated.length} phrases file${generated.length === 1 ? '' : 's'}.`);
-    }
     return { fns, outFns: features.map((f) => f.outFile.name) };
 }
 export async function compileFile(fn) {
-    var _a;
     fn = resolve(fn);
     const src = preprocess(readFileSync(fn, 'utf8').toString());
     try {
-        const { outFile, phrasesFile } = compileFeature(fn, src);
+        const { outFile } = compileFeature(fn, src);
         writeFileSync(outFile.name, outFile.value);
-        let phrasesFileAction = 'ignored';
-        if (!existsSync(phrasesFile.name)) {
-            phrasesFileAction = 'generated';
-            writeFileSync(phrasesFile.name, phrasesFile.value);
-        }
-        return { phrasesFileAction, outFile, phrasesFile };
+        return { outFile };
     }
     catch (e) {
-        const outFileName = testFileName(fn);
-        writeFileSync(outFileName, VitestGenerator.error((_a = e.message) !== null && _a !== void 0 ? _a : `${e}`, e.stack));
         return undefined;
     }
 }

package/{model → dist/model}/model.d.ts

@@ -14,6 +14,14 @@ export interface CodeGenerator {
     codeLiteral(src: string): string;
     stringParamDeclaration(index: number): string;
     variantParamDeclaration(index: number): string;
+    phraseMethods: PhraseMethod[];
+}
+export interface PhraseMethod {
+    name: string;
+    parameters: {
+        name: string;
+        type: string;
+    }[];
 }
 export interface Location {
     line: number;

package/dist/phrases_assistant/phrases_assistant.d.ts

@@ -0,0 +1,13 @@
+import * as t from 'ts-morph';
+import { PhraseMethod } from '../model/model';
+export declare class PhrasesAssistant {
+    project: t.Project;
+    file: t.SourceFile;
+    clazz: t.ClassDeclaration;
+    constructor(content: string, className: string);
+    ensureMethods(methods: PhraseMethod[]): void;
+    ensureMethod(method: PhraseMethod): void;
+    addMethod(method: PhraseMethod): void;
+    sortMethods(): void;
+    toCode(): string;
+}

package/dist/phrases_assistant/phrases_assistant.js

@@ -0,0 +1,146 @@
+import * as t from 'ts-morph';
+export class PhrasesAssistant {
+    constructor(content, className) {
+        var _a;
+        this.project = new t.Project({
+            useInMemoryFileSystem: true,
+        });
+        this.file = this.project.createSourceFile('filename.ts', content, {
+            overwrite: true,
+        });
+        const clazz = this.file.getClass(className);
+        if (!clazz) {
+            const defaultExport = this.file.getDefaultExportSymbol();
+            if (defaultExport) {
+                const decl = defaultExport.getDeclarations()[0];
+                if (t.Node.isClassDeclaration(decl)) {
+                    this.clazz = decl;
+                    this.clazz.rename(className);
+                }
+            }
+        }
+        else {
+            this.clazz = clazz;
+            if (!this.clazz.isDefaultExport()) {
+                this.clazz.setIsDefaultExport(true);
+            }
+        }
+        (_a = this.clazz) !== null && _a !== void 0 ? _a : (this.clazz = this.file.addClass({
+            name: className,
+            isDefaultExport: true,
+        }));
+    }
+    ensureMethods(methods) {
+        for (const method of methods) {
+            this.ensureMethod(method);
+        }
+        this.clazz
+            .getMethods()
+            .filter((m) => !methods.find((md) => md.name === m.getName()))
+            .forEach((m) => {
+            if (m.getStatements().length === 1 &&
+                m
+                    .getStatements()[0]
+                    .getText()
+                    .match(/throw new Error\(["']TODO /)) {
+                m.remove();
+            }
+        });
+        this.sortMethods();
+    }
+    ensureMethod(method) {
+        let existing = this.clazz.getMethod(method.name);
+        if (!existing) {
+            this.addMethod(method);
+        }
+    }
+    addMethod(method) {
+        const m = this.clazz.addMethod({
+            isAsync: true,
+            name: method.name,
+            parameters: method.parameters,
+            statements: [`throw new Error("TODO ${method.name}");`],
+        });
+        m.formatText({ indentSize: 2 });
+    }
+    sortMethods() {
+        const groups = ['When_', 'Then_'];
+        const members = this.clazz.getMembersWithComments();
+        const sorted = members.slice().sort((a, b) => {
+            const kindA = t.Node.isMethodDeclaration(a)
+                ? groups.findIndex((g) => a.getName().startsWith(g))
+                : -1;
+            const kindB = t.Node.isMethodDeclaration(b)
+                ? groups.findIndex((g) => b.getName().startsWith(g))
+                : -1;
+            if (kindA !== kindB) {
+                return kindA - kindB;
+            }
+            if (kindA === -1 && kindB === -1) {
+                return 0;
+            }
+            if (!t.Node.isMethodDeclaration(a) || !t.Node.isMethodDeclaration(b)) {
+                // never happens
+                return 0;
+            }
+            return a.getName() < b.getName() ? -1 : 1;
+        });
+        const moves = calculateMoves(members, sorted);
+        for (const move of moves) {
+            const method = members[move.fromIndex];
+            if (t.Node.isCommentClassElement(method)) {
+                // something went wrong
+                return;
+            }
+            method.setOrder(move.toIndex);
+            const [moved] = members.splice(move.fromIndex, 1);
+            members.splice(move.toIndex, 0, moved);
+        }
+    }
+    toCode() {
+        let s = this.file.getFullText();
+        // fix extra space
+        const closing = this.clazz.getEnd() - 1;
+        if (s.slice(closing - 2, closing + 1) === '\n }') {
+            s = s.slice(0, closing - 1) + s.slice(closing);
+        }
+        return s;
+    }
+}
+/**
+ * Calculates a set of move operations to transform one array into another.
+ * Both arrays must contain the same elements, just in different order.
+ *
+ * @param actual - The current array that needs to be reordered
+ * @param desired - The target array with the desired order
+ * @returns Array of move operations {fromIndex, toIndex} that transform actual into desired
+ */
+function calculateMoves(actual, desired) {
+    if (actual.length !== desired.length) {
+        throw new Error('Arrays must have the same length');
+    }
+    // Create a working copy to track changes
+    const working = [...actual];
+    const moves = [];
+    // For each position in the desired array
+    for (let targetIndex = 0; targetIndex < desired.length; targetIndex++) {
+        const targetElement = desired[targetIndex];
+        // Find where this element currently is in our working array
+        const currentIndex = working.indexOf(targetElement);
+        if (currentIndex === -1) {
+            throw new Error('Arrays must contain the same elements');
+        }
+        // If it's not in the right position, move it
+        if (currentIndex !== targetIndex) {
+            // Record the move operation
+            moves.push({
+                fromIndex: currentIndex,
+                toIndex: targetIndex,
+            });
+            // Apply the move to our working array
+            const [movedElement] = working.splice(currentIndex, 1);
+            working.splice(targetIndex, 0, movedElement);
+        }
+    }
+    return moves;
+}

package/dist/vitest/index.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'vite';
+import { CompilerOptions } from '../compiler/compile.ts';
+export interface HarmonyPluginOptions extends Partial<CompilerOptions> {
+    autoEditPhrases?: boolean;
+}
+export default function harmonyPlugin(opts?: HarmonyPluginOptions): Plugin;
+declare module 'vitest' {
+    interface TaskMeta {
+        phrases?: string[];
+    }
+}

package/{vitest → dist/vitest}/index.js

@@ -1,7 +1,13 @@
+import { readFile, writeFile } from 'fs/promises';
 import c from 'tinyrainbow';
 import { compileFeature } from "../compiler/compile.js";
 import { preprocess } from "../compiler/compiler.js";
-export default function harmonyPlugin({} = {}) {
+import { PhrasesAssistant } from "../phrases_assistant/phrases_assistant.js";
+const DEFAULT_OPTIONS = {
+    autoEditPhrases: true,
+};
+export default function harmonyPlugin(opts = {}) {
+    const options = { ...DEFAULT_OPTIONS, ...opts };
     return {
         name: 'harmony',
         resolveId(id) {
@@ -9,11 +15,14 @@ export default function harmonyPlugin({} = {}) {
                 return id;
             }
         },
-        transform(code, id, options) {
+        transform(code, id) {
             if (!id.endsWith('.harmony'))
                 return null;
             code = preprocess(code);
-            const { outFile } = compileFeature(id, code);
+            const { outFile, phraseMethods, featureClassName } = compileFeature(id, code, opts);
+            if (options.autoEditPhrases) {
+                void updatePhrasesFile(id, phraseMethods, featureClassName);
+            }
             return {
                 code: outFile.valueWithoutSourceMap,
                 map: outFile.sourceMap,
@@ -29,16 +38,6 @@ export default function harmonyPlugin({} = {}) {
             }
             config.test.reporters.splice(0, 0, new HarmonyReporter());
         },
-        // This has been removed in favor of using transform, so no need to generate an actual file
-        // async configureServer(server) {
-        //   const isWatchMode = server.config.server.watch !== null
-        //   const patterns = [`${watchDir}/**/*.harmony`]
-        //   if (isWatchMode) {
-        //     await watchFiles(patterns)
-        //   } else {
-        //     await compileFiles(patterns)
-        //   }
-        // },
     };
 }
 class HarmonyReporter {
@@ -82,3 +81,21 @@ function addPhrases(task, depth = 2) {
         delete task.meta.phrases; // to make sure not to add them again
     }
 }
+async function updatePhrasesFile(id, phraseMethods, featureClassName) {
+    try {
+        const phrasesFile = id.replace(/\.harmony$/, '.phrases.ts');
+        let phrasesFileContent = '';
+        try {
+            phrasesFileContent = await readFile(phrasesFile, 'utf-8');
+        }
+        catch {
+            // File doesn't exist
+        }
+        const pa = new PhrasesAssistant(phrasesFileContent, featureClassName);
+        pa.ensureMethods(phraseMethods);
+        await writeFile(phrasesFile, pa.toCode());
+    }
+    catch (e) {
+        console.error('Error updating phrases file:', e);
+    }
+}

package/package.json

@@ -1,49 +1,46 @@
 {
   "name": "harmonyc",
-  "description": "Harmony Code - model-driven BDD for Vitest",
-  "version": "0.18.1",
-  "author": "Bernát Kalló",
+  "version": "0.20.0",
   "type": "module",
-  "bin": {
-    "harmonyc": "./cli.js"
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "harmonyc": "tsx ./src/cli/cli",
+    "test": "vitest --run",
+    "test:compile": "tsx ./src/cli/cli 'src/**/*.harmony'",
+    "dev": "vitest --watch",
+    "publish": "npm publish",
+    "release": "npm run build && release publish"
   },
+  "files": [
+    "dist"
+  ],
   "exports": {
     "./vitest": {
-      "types": "./vitest/index.d.ts",
-      "default": "./vitest/index.js"
+      "types": "./dist/vitest/index.d.ts",
+      "default": "./dist/vitest/index.js"
     }
   },
-  "homepage": "https://github.com/harmony-ac/code#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/harmony-ac/code.git"
-  },
-  "bugs": {
-    "url": "https://github.com/harmony-ac/code/issues"
+  "bin": {
+    "harmonyc": "./dist/cli/cli.js"
   },
   "dependencies": {
     "fast-glob": "^3.3.2",
     "tinyrainbow": "1",
+    "ts-morph": "^27.0.2",
     "typescript-parsec": "0.3.4"
   },
   "optionalDependencies": {
     "watcher": "^2.3.1"
   },
-  "license": "MIT",
-  "keywords": [
-    "unit test",
-    "unit testing",
-    "bdd",
-    "behavior-driven",
-    "test design",
-    "test design automation",
-    "harmony.ac",
-    "test framework",
-    "model-based test",
-    "model-based testing",
-    "test model",
-    "test modeling",
-    "test modelling",
-    "vitest"
-  ]
-}
+  "devDependencies": {
+    "@ossjs/release": "^0.10.0",
+    "@types/debug": "^4.1.12",
+    "@types/node": "^22.10.6",
+    "expect": "^29.7.0",
+    "tsx": "^4.7.1",
+    "typescript": "^5.3.3",
+    "vite": "^7.1.10",
+    "vitest": "^3.2.4"
+  }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024-2025 Bernát Kalló
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,142 +0,0 @@
-# Harmony Code
-
-A test design & BDD tool that helps you separate _what_ you test and _how_ you automate it. You write test cases in a simple easy-to-read format, and then automate them with Vitest.
-
-## Setup
-
-You need to have Node.js installed. Then you can install Harmony Code in your project folder by:
-
-```bash
-npm install harmonyc
-```
-
-Then add it as a plugin to your `vitest.config.js` or `vite.config.js` file, and make sure to include your `.harmony` files:
-
-```js
-import harmony from 'harmonyc/vitest'
-
-export default {
-  plugins: [harmony()],
-  include: ['src/**/*.harmony'],
-}
-```
-
-This will run .harmony files in vitest.
-
-## VSCode plugin
-
-Harmony Code has a [VSCode plugin](https://marketplace.visualstudio.com/items?itemName=harmony-ac.harmony-code) that supports syntax highlighting.
-
-Harmony Code is compatible with Vitest's VSCode plugin, so you can run and debug tests from the editor.
-
-## Syntax
-
-A `.harmony` file is a text file with a syntax that looks like this:
-
-```
-+ Products API:
-  + Create:
-    + Anonymous:
-      - create product => !! "unauthorized"
-    + Admin:
-      - authenticate with "admin" => product count `0`
-      - create product
-        => product created
-        => product count `1`
-      - Delete:
-        - delete product => product deleted => product count `0`
-```
-
-### Indentation
-
-The lines of a file are nodes of a tree. The tree is specified with the indentation of the lines, which is n times 2 spaces and a `+` or `-` with one more space. The `+` or `-` sign is considered to be part of the indentation.
-
-### Sequences and forks
-
-`-` means a sequence: the node follows the previous sibling node and its descendants.
-
-`+` means a fork: the node directly follows its parent node. All siblings with `+` are separate branches, they will generate separate scenarios.
-
-### Phrases (actions and responses)
-
-After the mark, every node can contain an **action** and zero or more **responses**, together called **phrases**. The action is the text before the `=>`, and the responses are the text after the `=>`.
-
-Both actions and responses get compiled to simple function calls - in JavaScript, awaited function calls. Actions will become `When_*` functions, and responses will become `Then_*` functions. The return value of the action is passed to the responses of the same step as the last argument.
-
-### Arguments
-
-Phrases (actions and responses) can have arguments which are passed to the implementation function. There are two types of arguments: strings and code fragments:
-
-```harmony
-+ strings:
-  + hello "John"
-+ code fragment:
-  + greet `3` times
-```
-
-becomes
-
-```javascript
-test('T1 - strings', async () => {
-  const P = new Phrases()
-  await P.When_hello_('John')
-})
-test('T2 - code fragment', async () => {
-  const P = new Phrases()
-  await P.When_greet__times(3)
-})
-```
-
-### Labels
-
-Labels are lines that start with `-` or `+` and end with `:`. You can use them to structure your test design.
-They are not included in the test case, but the test case name is generated from the labels.
-
-### Comments
-
-Lines starting with `#` or `//` are comments and are ignored.
-
-### Switches
-
-You can generate multiple test cases by adding a `{ A / B / C }` syntax into action(s) and possibly response(s).
-
-```harmony
-+ password is { "A" / "asdf" / "password123" } => !! "password is too weak"
-```
-
-### Error matching
-
-You can use `!!` to denote an error response. This will verify that the action throws an error. You can specify the error message after the `!!`.
-
-### Variables
-
-You can set variables in the tests and use them in strings and code fragments:
-
-```
-+ set variable:
-  + ${name} "John"
-    + greet "${name}" => "hello John"
-+ store result into variable:
-  + run process => ${result}
-    + "${result}" is "success"
-```
-
-becomes
-
-```javascript
-test('T1 - set variable', (context) => {
-  const P = new Phrases();
-  (context.task.meta.variables ??= {})['name'] = "John";
-  await P.When_greet_(context.task.meta.variables?.['name']);
-})
-test('T2 - store result in variable', (context) => {
-  const P = new Phrases();
-  const r = await P.When_run_process();
-  (context.task.meta.variables ??= {})['result'] = r;
-  await P.Then__is_(`${context.task.meta.variables?.['result']});
-})
-```
-
-## License
-
-MIT

package/compiler/compile.d.ts

@@ -1,9 +0,0 @@
-import { OutFile } from '../code_generator/outFile.ts';
-export interface CompiledFeature {
-    name: string;
-    code: Record<string, string>;
-}
-export declare function compileFeature(fileName: string, src: string): {
-    outFile: OutFile;
-    phrasesFile: OutFile;
-};

package/vitest/index.d.ts

@@ -1,9 +0,0 @@
-import type { Plugin } from 'vite';
-export interface HarmonyPluginOptions {
-}
-export default function harmonyPlugin({}?: HarmonyPluginOptions): Plugin;
-declare module 'vitest' {
-    interface TaskMeta {
-        phrases?: string[];
-    }
-}