@dusted/anqst 0.1.0

package/LICENSE

@@ -0,0 +1,13 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.

package/README.md

@@ -0,0 +1,136 @@
+# AnQstGen
+
+Isolated TypeScript implementation of the `anqst` generator CLI npm package.
+
+## Build and run locally
+
+```bash
+npm install
+npm run build
+```
+
+Run directly from build output:
+
+```bash
+node dist/src/bin/anqst.js <command> [args]
+```
+
+Optional: expose the command in your shell while developing:
+
+```bash
+npm link
+# now you can run: anqst <command> [args]
+```
+
+Run via npx (preferred package workflow):
+
+```bash
+npx @dusted/anqst <command> [args]
+```
+
+## CLI commands
+
+- `anqst instill <WidgetName>`
+  - Must be run in a directory containing `package.json`.
+  - Fails if `package.json.AnQst` already exists.
+  - Adds:
+    - `"AnQst": { "spec": "<WidgetName>.AnQst.d.ts", "generate": ["QWidget", "AngularService", "//DOM", "//node_express_ws"] }`
+    - `build` script prefix: `npx anqst build`
+    - `test` script prefix: `npx anqst test`
+  - Scaffolds `<WidgetName>.AnQst.d.ts` in project root.
+  - Installs a project-local DSL definition at `anqst-dsl/AnQst-Spec-DSL.d.ts`.
+
+- `anqst test`
+  - Reads `package.json.AnQst.spec`.
+  - Verifies the configured spec.
+  - On first error: prints readable error and exits `1`.
+  - On success: prints summary and exits `0`.
+
+- `anqst build`
+  - Reads `package.json.AnQst.spec`.
+  - Reads optional `package.json.AnQst.generate` string array to select emitted outputs:
+    - `"QWidget"` enables Qt/C++ emission and embedding flow.
+    - `"AngularService"` enables TypeScript service package emission/install.
+    - `"node_express_ws"` enables Node/Express backend bridge package emission.
+    - Empty list is valid and emits nothing.
+    - `//DOM` and `//node_express_ws` remain accepted placeholders and are ignored.
+  - Verifies and generates outputs.
+  - Writes raw outputs to `<cwd>/generated_output`:
+    - TypeScript package sources under `generated_output/npmpackage`
+    - C++ widget library sources plus CMake environment under `generated_output/<WidgetName>_QtWidget`
+    - Node/Express backend package sources under `generated_output/<WidgetName>_node_express_ws`
+  - When `"AngularService"` is enabled:
+    - Replaces installed TypeScript artifacts in `<cwd>/src/anqst-generated`.
+  - When `"QWidget"` is enabled:
+    - Writes Qt integration glue to `<cwd>/anqst-cmake/CMakeLists.txt` so Qt consumers can `add_subdirectory(...)` and link `<WidgetName>Widget`.
+    - If an Angular project is detected (`angular.json` exists), runs a production `ng build`.
+    - Embeds the built web bundle into the generated widget library under `generated_output/<WidgetName>_QtWidget/webapp/*`.
+
+- `anqst generate <specFile>`
+  - Verifies the provided spec file and generates raw output.
+  - Also applies `package.json.AnQst.generate` when `package.json` is present and contains `AnQst`.
+  - If `"AngularService"` is enabled, installs into `src/anqst-generated`.
+  - If `"QWidget"` is enabled, writes `anqst-cmake/CMakeLists.txt`.
+  - If `"node_express_ws"` is enabled, emits `generated_output/<WidgetName>_node_express_ws`.
+  - If no package config is present, defaults to emitting both QWidget and AngularService outputs.
+  - Writes to `<cwd>/generated_output`.
+
+- `anqst verify <specFile>`
+  - Verifies a spec file without generating artifacts.
+
+- `anqst clean <path> [-f|--force]`
+  - `<path>` may be absolute or relative to current working directory.
+  - Without `--force`:
+    - requires `<path>/package.json` with `AnQst.spec`
+    - removes only widget-scoped generated folders for the referenced widget.
+  - With `--force`:
+    - removes broad generated folders under `<path>` regardless of package metadata.
+  - Reports grouped cleanup results: `Deleted`, `Not found`, `Failed`.
+  - Groups with zero entries are omitted from the output.
+
+## Typical usage flow (Angular widget project)
+
+```bash
+# 1) in your widget project
+npx @dusted/anqst instill BurgerConstructor
+
+# 2) edit generated spec scaffold
+code BurgerConstructor.AnQst.d.ts
+
+# 3) validate spec
+npx @dusted/anqst test
+
+# 4) generate and install artifacts
+npx @dusted/anqst build
+
+# or via npm scripts enriched by instill
+npm run test
+npm run build
+```
+
+## Generated output structure
+
+When generation succeeds:
+
+- `generated_output/npmpackage/package.json`
+- `generated_output/npmpackage/index.ts`
+- `generated_output/npmpackage/services.ts`
+- `generated_output/npmpackage/types.ts`
+- `generated_output/npmpackage/index.js`
+- `generated_output/npmpackage/services.js`
+- `generated_output/npmpackage/types.js`
+- `generated_output/npmpackage/types/index.d.ts`
+- `generated_output/npmpackage/types/services.d.ts`
+- `generated_output/npmpackage/types/types.d.ts`
+- `generated_output/<WidgetName>_QtWidget/CMakeLists.txt`
+- `generated_output/<WidgetName>_QtWidget/<WidgetName>.qrc`
+- `generated_output/<WidgetName>_QtWidget/include/<WidgetName>.h`
+- `generated_output/<WidgetName>_QtWidget/include/<WidgetName>Types.h`
+- `generated_output/<WidgetName>_QtWidget/<WidgetName>.cpp`
+- `generated_output/<WidgetName>_QtWidget/webapp/*` (embedded Angular build artifacts)
+- Generated CMake links the widget library target (`<WidgetName>Widget`) against `anqstwebhostbase`.
+- `anqst-cmake/CMakeLists.txt` (consumer-facing CMake entrypoint that triggers on-demand Angular/anqst build)
+
+And after `anqst build`:
+
+- `src/anqst-generated/*` (installed TypeScript artifacts, replaced on each build)

package/dist/src/app.js

@@ -0,0 +1,369 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVerify = runVerify;
+exports.runGenerate = runGenerate;
+exports.runTest = runTest;
+exports.runBuild = runBuild;
+exports.runClean = runClean;
+exports.runCommand = runCommand;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_child_process_1 = require("node:child_process");
+const parser_1 = require("./parser");
+const verify_1 = require("./verify");
+const errors_1 = require("./errors");
+const emit_1 = require("./emit");
+const project_1 = require("./project");
+function renderHelp() {
+    return [
+        "Usage:",
+        "  anqst <command> [arguments] [options]",
+        "",
+        "Commands:",
+        "  instill <WidgetName>       Initialize AnQst in current npm project",
+        "  test                        Verify package.json AnQst spec",
+        "  build                       Generate artifacts from package.json AnQst spec",
+        "  generate <specFile>         Generate artifacts from explicit spec file",
+        "  verify <specFile>           Verify explicit spec file only",
+        "  clean <path> [-f|--force]   Remove generated artifacts under path",
+        "",
+        "Options:",
+        "  -h, --help                  Show this help output"
+    ].join("\n");
+}
+function usageFor(command) {
+    if (command === "instill")
+        return "Usage: anqst instill <WidgetName>";
+    if (command === "verify")
+        return "Usage: anqst verify <specFile>";
+    if (command === "generate")
+        return "Usage: anqst generate <specFile>";
+    if (command === "clean")
+        return "Usage: anqst clean <path> [-f|--force]";
+    return renderHelp();
+}
+function runVerify(specArg) {
+    const specPath = node_path_1.default.resolve(process.cwd(), specArg);
+    const parsed = (0, parser_1.parseSpecFile)(specPath);
+    const verification = (0, verify_1.verifySpec)(parsed);
+    return {
+        success: true,
+        message: verification.message
+    };
+}
+function runGenerate(specArg) {
+    const cwd = process.cwd();
+    const specPath = node_path_1.default.resolve(cwd, specArg);
+    const parsed = (0, parser_1.parseSpecFile)(specPath);
+    const verification = (0, verify_1.verifySpec)(parsed);
+    const generationTargets = resolveGenerationTargetsFromCwd(cwd);
+    const outputs = (0, emit_1.generateOutputs)(parsed, generationTargets);
+    (0, emit_1.writeGeneratedOutputs)(cwd, outputs);
+    if (generationTargets.emitAngularService) {
+        (0, emit_1.installTypeScriptOutputs)(cwd);
+    }
+    if (generationTargets.emitQWidget) {
+        (0, emit_1.installQtIntegrationCMake)(cwd, parsed.widgetName);
+    }
+    const relativeSpecFile = normalizeSlashes(node_path_1.default.relative(cwd, specPath));
+    const relativeTypeScriptInstallPath = normalizeSlashes(node_path_1.default.relative(cwd, node_path_1.default.join(cwd, "src", "anqst-generated")));
+    const relativeCppLibraryPath = normalizeSlashes(node_path_1.default.relative(cwd, node_path_1.default.join(cwd, "generated_output", `${parsed.widgetName}_QtWidget`)));
+    const relativeNodeModulePath = normalizeSlashes(node_path_1.default.relative(cwd, node_path_1.default.join(cwd, "generated_output", `${parsed.widgetName}_node_express_ws`)));
+    const serviceList = parsed.services.map((s) => s.name).join(", ");
+    const messageLines = [];
+    messageLines.push(`AnQst spec ${relativeSpecFile} built.`);
+    if (generationTargets.emitAngularService) {
+        messageLines.push(`    Services ${serviceList} are available from ${relativeTypeScriptInstallPath}/services.`);
+        messageLines.push(`    Generated types are available from ${relativeTypeScriptInstallPath}/types.`);
+    }
+    if (generationTargets.emitQWidget) {
+        messageLines.push(`    Widget library available in ${relativeCppLibraryPath}.`);
+    }
+    if (generationTargets.emitNodeExpressWs) {
+        messageLines.push(`    Node Express WS module available in ${relativeNodeModulePath}.`);
+    }
+    if (!generationTargets.emitAngularService && !generationTargets.emitQWidget && !generationTargets.emitNodeExpressWs) {
+        messageLines.push("    No outputs selected by AnQst.generate.");
+    }
+    return {
+        success: true,
+        verificationMessage: verification.message,
+        message: `\n${messageLines.join("\n")}\n`
+    };
+}
+function runTest(cwd) {
+    const specPath = (0, project_1.resolveAnQstSpecPath)(cwd);
+    const parsed = (0, parser_1.parseSpecFile)(specPath);
+    const verification = (0, verify_1.verifySpec)(parsed);
+    return {
+        success: true,
+        message: verification.message
+    };
+}
+function runBuild(cwd) {
+    const specPath = (0, project_1.resolveAnQstSpecPath)(cwd);
+    const generationTargets = resolveGenerationTargetsFromCwd(cwd, true);
+    const parsed = (0, parser_1.parseSpecFile)(specPath);
+    (0, verify_1.verifySpec)(parsed);
+    const outputs = (0, emit_1.generateOutputs)(parsed, generationTargets);
+    (0, emit_1.writeGeneratedOutputs)(cwd, outputs);
+    if (generationTargets.emitAngularService) {
+        (0, emit_1.installTypeScriptOutputs)(cwd);
+    }
+    if (generationTargets.emitQWidget) {
+        (0, emit_1.installQtIntegrationCMake)(cwd, parsed.widgetName);
+    }
+    const hasAngularProject = generationTargets.emitQWidget && node_fs_1.default.existsSync(node_path_1.default.join(cwd, "angular.json"));
+    if (hasAngularProject && generationTargets.emitQWidget) {
+        const angularBuild = (0, node_child_process_1.spawnSync)("npx", ["ng", "build", "--configuration", "production"], {
+            cwd,
+            stdio: "inherit",
+            shell: process.platform === "win32"
+        });
+        if (angularBuild.status !== 0) {
+            throw new errors_1.VerifyError("Angular build failed while preparing embedded widget assets.");
+        }
+    }
+    if (generationTargets.emitQWidget) {
+        const embedded = (0, emit_1.installEmbeddedWebBundle)(cwd, parsed.widgetName);
+        if (hasAngularProject && !embedded) {
+            throw new errors_1.VerifyError("Unable to embed Angular output. Ensure ng build produced a dist bundle with index.html.");
+        }
+    }
+    if (!generationTargets.emitAngularService && !generationTargets.emitQWidget && !generationTargets.emitNodeExpressWs) {
+        return {
+            success: true,
+            message: "Build completed: no outputs selected by AnQst.generate"
+        };
+    }
+    const parts = [];
+    if (generationTargets.emitAngularService) {
+        parts.push("TypeScript installed to src/anqst-generated");
+    }
+    if (generationTargets.emitQWidget) {
+        parts.push("Qt integration CMake emitted to anqst-cmake/");
+        parts.push("C++ widget library refreshed with embedded web assets");
+    }
+    if (generationTargets.emitNodeExpressWs) {
+        parts.push(`Node Express WS module emitted to generated_output/${parsed.widgetName}_node_express_ws`);
+    }
+    return {
+        success: true,
+        message: `Build completed: ${parts.join(", ")}`
+    };
+}
+function parseCleanCommandArgs(specArg, extraArgs) {
+    const allArgs = [specArg, ...extraArgs].filter((arg) => typeof arg === "string" && arg.length > 0);
+    let force = false;
+    let targetPathArg = null;
+    for (const arg of allArgs) {
+        if (arg === "-f" || arg === "--force") {
+            force = true;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`Unknown clean flag '${arg}'. Use -f or --force.`);
+        }
+        if (targetPathArg !== null) {
+            throw new Error(`Unexpected extra argument '${arg}'. Usage: anqst clean <path> [-f|--force]`);
+        }
+        targetPathArg = arg;
+    }
+    if (targetPathArg === null) {
+        throw new Error("Usage: anqst clean <path> [-f|--force]");
+    }
+    return { targetPathArg, force };
+}
+function runCleanup(targetRoot, relativeDirs) {
+    const rows = [];
+    for (const relativePath of relativeDirs) {
+        const absolutePath = node_path_1.default.join(targetRoot, relativePath);
+        if (!node_fs_1.default.existsSync(absolutePath)) {
+            rows.push({ relativePath, status: "not_found" });
+            continue;
+        }
+        try {
+            if (!node_fs_1.default.statSync(absolutePath).isDirectory()) {
+                rows.push({
+                    relativePath,
+                    status: "failed",
+                    reason: "Path exists but is not a directory."
+                });
+                continue;
+            }
+            node_fs_1.default.rmSync(absolutePath, { recursive: true, force: false });
+            rows.push({ relativePath, status: "deleted" });
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            rows.push({ relativePath, status: "failed", reason });
+        }
+    }
+    return rows;
+}
+function formatCleanResult(targetRoot, rows) {
+    const deleted = rows.filter((row) => row.status === "deleted");
+    const notFound = rows.filter((row) => row.status === "not_found");
+    const failed = rows.filter((row) => row.status === "failed");
+    const lines = [];
+    lines.push(`[AnQst] Clean summary for ${normalizeSlashes(targetRoot)}`);
+    if (deleted.length > 0) {
+        lines.push(`  Deleted (${deleted.length})`);
+        for (const row of deleted)
+            lines.push(`    - ${row.relativePath}`);
+    }
+    if (notFound.length > 0) {
+        lines.push(`  Not found (${notFound.length})`);
+        for (const row of notFound)
+            lines.push(`    - ${row.relativePath}`);
+    }
+    if (failed.length > 0) {
+        lines.push(`  Failed (${failed.length})`);
+        for (const row of failed)
+            lines.push(`    - ${row.relativePath}: ${row.reason ?? "Unknown error"}`);
+    }
+    return lines.join("\n");
+}
+function resolveGenerationTargetsFromCwd(cwd, requirePackageAnQst = false) {
+    const packagePath = node_path_1.default.join(cwd, "package.json");
+    if (!node_fs_1.default.existsSync(packagePath)) {
+        if (requirePackageAnQst) {
+            throw new errors_1.VerifyError("No package.json: Can only build AnQst inside an npm project.");
+        }
+        return toGenerationTargets([...project_1.DEFAULT_ANQST_GENERATE_TARGETS]);
+    }
+    const packageJson = JSON.parse(node_fs_1.default.readFileSync(packagePath, "utf8"));
+    if (packageJson.AnQst === undefined) {
+        if (requirePackageAnQst) {
+            throw new errors_1.VerifyError("Missing package.json key 'AnQst.spec'. Run 'anqst instill <WidgetName>' first.");
+        }
+        return toGenerationTargets([...project_1.DEFAULT_ANQST_GENERATE_TARGETS]);
+    }
+    return toGenerationTargets((0, project_1.resolveAnQstGenerateTargets)(cwd));
+}
+function toGenerationTargets(targets) {
+    return {
+        emitQWidget: targets.includes("QWidget"),
+        emitAngularService: targets.includes("AngularService"),
+        emitNodeExpressWs: targets.includes("node_express_ws")
+    };
+}
+function resolveAnQstSpecFromPackage(targetRoot) {
+    const packagePath = node_path_1.default.join(targetRoot, "package.json");
+    if (!node_fs_1.default.existsSync(packagePath)) {
+        throw new Error(`No package.json with an AnQst key found at '${normalizeSlashes(targetRoot)}'. Use 'anqst clean ${normalizeSlashes(targetRoot)} --force' to clean anyway.`);
+    }
+    const packageJson = JSON.parse(node_fs_1.default.readFileSync(packagePath, "utf8"));
+    const spec = packageJson.AnQst?.spec;
+    if (!spec || spec.trim().length === 0) {
+        throw new Error(`No package.json with an AnQst key found at '${normalizeSlashes(targetRoot)}'. Use 'anqst clean ${normalizeSlashes(targetRoot)} --force' to clean anyway.`);
+    }
+    return node_path_1.default.resolve(targetRoot, spec);
+}
+function runClean(pathArg, force) {
+    const targetRoot = node_path_1.default.resolve(process.cwd(), pathArg);
+    const broadDirs = [
+        "generated_output",
+        node_path_1.default.join("src", "anqst-generated"),
+        "anqst-cmake"
+    ];
+    if (force) {
+        const rows = runCleanup(targetRoot, broadDirs);
+        return {
+            success: true,
+            message: formatCleanResult(targetRoot, rows),
+            hadFailures: rows.some((row) => row.status === "failed")
+        };
+    }
+    const specPath = resolveAnQstSpecFromPackage(targetRoot);
+    const parsed = (0, parser_1.parseSpecFile)(specPath);
+    const widgetDirs = [
+        node_path_1.default.join("generated_output", `${parsed.widgetName}_QtWidget`),
+        node_path_1.default.join("generated_output", `${parsed.widgetName}_node_express_ws`),
+        node_path_1.default.join("src", "anqst-generated"),
+        "anqst-cmake"
+    ];
+    const rows = runCleanup(targetRoot, widgetDirs);
+    return {
+        success: true,
+        message: formatCleanResult(targetRoot, rows),
+        hadFailures: rows.some((row) => row.status === "failed")
+    };
+}
+function normalizeSlashes(inputPath) {
+    return inputPath.split(node_path_1.default.sep).join("/");
+}
+function runCommand(command, specArg, extraArgs = []) {
+    try {
+        if (!command) {
+            console.error(renderHelp());
+            return 1;
+        }
+        if (command === "-h" || command === "--help" || command === "help") {
+            console.log(renderHelp());
+            return 0;
+        }
+        if (command === "instill") {
+            if (!specArg) {
+                console.error(usageFor("instill"));
+                return 1;
+            }
+            const msg = (0, project_1.runInstill)(process.cwd(), specArg);
+            console.log(msg);
+            return 0;
+        }
+        if (command === "test") {
+            const res = runTest(process.cwd());
+            console.log(res.message);
+            return 0;
+        }
+        if (command === "build") {
+            const res = runBuild(process.cwd());
+            console.log(res.message);
+            return 0;
+        }
+        if (command === "verify") {
+            if (!specArg) {
+                console.error(usageFor("verify"));
+                return 1;
+            }
+            const res = runVerify(specArg);
+            console.log(res.message);
+            return 0;
+        }
+        if (command === "generate") {
+            if (!specArg) {
+                console.error(usageFor("generate"));
+                return 1;
+            }
+            const res = runGenerate(specArg);
+            if (res.verificationMessage) {
+                console.log(res.verificationMessage);
+            }
+            console.log(res.message);
+            return 0;
+        }
+        if (command === "clean") {
+            const parsed = parseCleanCommandArgs(specArg, extraArgs);
+            const res = runClean(parsed.targetPathArg, parsed.force);
+            console.log(res.message);
+            return res.hadFailures ? 1 : 0;
+        }
+        console.error(`anqst: unknown command '${command}'`);
+        console.error("");
+        console.error(renderHelp());
+        return 1;
+    }
+    catch (error) {
+        if (error instanceof errors_1.VerifyError) {
+            console.error((0, errors_1.formatVerifyError)(error));
+            return 1;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`[AnQst] ${message}`);
+        return 1;
+    }
+}

package/dist/src/bin/anqst.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const app_1 = require("../app");
+const [, , command, ...args] = process.argv;
+const [specArg, ...extraArgs] = args;
+const code = (0, app_1.runCommand)(command, specArg, extraArgs);
+process.exitCode = code;