@decohere/create 0.0.1-dev.17 → 0.0.1-dev.19

package/commonjs/src/cli.js

@@ -3,13 +3,38 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _nodepath = require("node:path");
 const _commander = require("commander");
-const _scaffold = require("./scaffold.js");
+const _runner = require("./runner.js");
+const _createapi = require("./webapi/create-api.js");
 const program = new _commander.Command();
-program.name("decohere").description("Scaffold a new Decohere project").argument("[directory]", "Target directory (default: current directory)", ".").option("-y, --yes", "Skip confirmation prompts").option("-t, --template <template>", "Project template: basic (default) or webapi", "basic").option("-d, --database <provider>", "Database provider to include (webapi only): typeorm").action(async (directory, opts)=>{
-    await (0, _scaffold.scaffold)((0, _nodepath.resolve)(directory), opts);
+program.name("decohere").description("Scaffold a new Decohere project").option("-d <directory>", "Target directory (default: current directory)", ".");
+program.command("webapi").action(async (_name, cmd)=>{
+    const opts = cmd.optsWithGlobals();
+    if (process.env.DECOHERE_BUILDER !== "1") {
+        (0, _runner.runInBuilder)(opts);
+        return;
+    }
+    await (0, _createapi.scaffoldApi)(opts);
 });
+// .option("-y, --yes", "Skip confirmation prompts")
+// .option("-t, --template <template>", "Project template: api (default) or cli")
+// .option("-d, --database <provider>", "Database provider to include (api only): typeorm")
+// .option("-i, --idp <provider>", "Identity provider to configure (api only): auth0")
+// .option("-p, --postman", "Configure a Postman workspace, collection, and environment")
+// .action(
+// 	async (
+// 		directory: string,
+// 		opts: {
+// 			yes?: boolean;
+// 			template?: "api" | "cli";
+// 			database?: "typeorm";
+// 			idp?: "auth0";
+// 			postman?: boolean;
+// 		},
+// 	) => {
+// 		await scaffold(resolve(directory), opts);
+// 	},
+// );
 program.parse();
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvY2xpLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIiMhL3Vzci9iaW4vZW52IG5vZGVcbmltcG9ydCB7IHJlc29sdmUgfSBmcm9tIFwibm9kZTpwYXRoXCI7XG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiO1xuaW1wb3J0IHsgc2NhZmZvbGQgfSBmcm9tIFwiLi9zY2FmZm9sZC5qc1wiO1xuXG5jb25zdCBwcm9ncmFtID0gbmV3IENvbW1hbmQoKTtcblxucHJvZ3JhbVxuXHQubmFtZShcImRlY29oZXJlXCIpXG5cdC5kZXNjcmlwdGlvbihcIlNjYWZmb2xkIGEgbmV3IERlY29oZXJlIHByb2plY3RcIilcblx0LmFyZ3VtZW50KFwiW2RpcmVjdG9yeV1cIiwgXCJUYXJnZXQgZGlyZWN0b3J5IChkZWZhdWx0OiBjdXJyZW50IGRpcmVjdG9yeSlcIiwgXCIuXCIpXG5cdC5vcHRpb24oXCIteSwgLS15ZXNcIiwgXCJTa2lwIGNvbmZpcm1hdGlvbiBwcm9tcHRzXCIpXG5cdC5vcHRpb24oXCItdCwgLS10ZW1wbGF0ZSA8dGVtcGxhdGU+XCIsIFwiUHJvamVjdCB0ZW1wbGF0ZTogYmFzaWMgKGRlZmF1bHQpIG9yIHdlYmFwaVwiLCBcImJhc2ljXCIpXG5cdC5vcHRpb24oXCItZCwgLS1kYXRhYmFzZSA8cHJvdmlkZXI+XCIsIFwiRGF0YWJhc2UgcHJvdmlkZXIgdG8gaW5jbHVkZSAod2ViYXBpIG9ubHkpOiB0eXBlb3JtXCIpXG5cdC5hY3Rpb24oXG5cdFx0YXN5bmMgKFxuXHRcdFx0ZGlyZWN0b3J5OiBzdHJpbmcsXG5cdFx0XHRvcHRzOiB7IHllcz86IGJvb2xlYW47IHRlbXBsYXRlPzogXCJiYXNpY1wiIHwgXCJ3ZWJhcGlcIjsgZGF0YWJhc2U/OiBcInR5cGVvcm1cIiB9LFxuXHRcdCkgPT4ge1xuXHRcdFx0YXdhaXQgc2NhZmZvbGQocmVzb2x2ZShkaXJlY3RvcnkpLCBvcHRzKTtcblx0XHR9LFxuXHQpO1xuXG5wcm9ncmFtLnBhcnNlKCk7XG4iXSwibmFtZXMiOlsicHJvZ3JhbSIsIkNvbW1hbmQiLCJuYW1lIiwiZGVzY3JpcHRpb24iLCJhcmd1bWVudCIsIm9wdGlvbiIsImFjdGlvbiIsImRpcmVjdG9yeSIsIm9wdHMiLCJzY2FmZm9sZCIsInJlc29sdmUiLCJwYXJzZSJdLCJtYXBwaW5ncyI6Ijs7Ozs7MEJBQ3dCOzJCQUNBOzBCQUNDO0FBRXpCLE1BQU1BLFVBQVUsSUFBSUMsa0JBQU87QUFFM0JELFFBQ0VFLElBQUksQ0FBQyxZQUNMQyxXQUFXLENBQUMsbUNBQ1pDLFFBQVEsQ0FBQyxlQUFlLGlEQUFpRCxLQUN6RUMsTUFBTSxDQUFDLGFBQWEsNkJBQ3BCQSxNQUFNLENBQUMsNkJBQTZCLCtDQUErQyxTQUNuRkEsTUFBTSxDQUFDLDZCQUE2Qix1REFDcENDLE1BQU0sQ0FDTixPQUNDQyxXQUNBQztJQUVBLE1BQU1DLElBQUFBLGtCQUFRLEVBQUNDLElBQUFBLGlCQUFPLEVBQUNILFlBQVlDO0FBQ3BDO0FBR0ZSLFFBQVFXLEtBQUsifQ==
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/domain/prompt.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get ask () {
+        return ask;
+    },
+    get pick () {
+        return pick;
+    }
+});
+const _nodereadline = require("node:readline");
+// readline/promises rl.question() has a race condition with piped (non-TTY) stdin
+// in Node ≥ 22: after the first line is read, stdin emits 'end', readline closes,
+// and all subsequent question() calls resolve to "".
+// Fix: use the async-iterator API, which buffers all lines before the close event fires.
+let _lines = null;
+function getLines() {
+    if (_lines == null) {
+        const rl = (0, _nodereadline.createInterface)({
+            input: process.stdin,
+            terminal: false
+        });
+        _lines = rl[Symbol.asyncIterator]();
+    }
+    return _lines;
+}
+async function readLine(prompt) {
+    process.stdout.write(prompt);
+    const { value, done } = await getLines().next();
+    return done ? "" : value.trim();
+}
+async function ask(question, fallback = "") {
+    const answer = await readLine(question);
+    return answer || fallback;
+}
+async function pick(label, items, display) {
+    console.log(label.trimEnd());
+    for (const [i, item] of items.entries()){
+        console.log(`    ${i + 1}. ${display(item)}`);
+    }
+    const answer = await readLine("  > ");
+    const idx = Number.parseInt(answer, 10);
+    if (Number.isNaN(idx) || idx < 1 || idx > items.length) return null;
+    return items[idx - 1];
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/models/compose.model.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DockerCompose", {
+    enumerable: true,
+    get: function() {
+        return DockerCompose;
+    }
+});
+const _const = require("./const.js");
+class DockerCompose {
+    key = _const.WELL_KNOWN_FILES.DOCKER_COMPOSE;
+    _services = new Map();
+    _volumes = new Set();
+    addService(name, config) {
+        this._services.set(name, config);
+        return this;
+    }
+    files() {
+        return [
+            {
+                filePath: ".devcontainer/docker-compose.yml",
+                content: this.getContent()
+            }
+        ];
+    }
+    addVolume(name) {
+        this._volumes.add(name);
+        return this;
+    }
+    /** Append an env_file path to an existing service. */ addEnvFile(serviceName, filePath) {
+        const svc = this._services.get(serviceName);
+        if (svc) svc.env_file = [
+            ...svc.env_file ?? [],
+            filePath
+        ];
+        return this;
+    }
+    getContent() {
+        const lines = [
+            "services:"
+        ];
+        for (const [name, svc] of this._services){
+            lines.push(`  ${name}:`);
+            if (svc.build) lines.push(`    build: ${svc.build}`);
+            if (svc.image) lines.push(`    image: ${svc.image}`);
+            if (svc.command) lines.push(`    command: ${svc.command}`);
+            if (svc.restart) lines.push(`    restart: ${svc.restart}`);
+            if (svc.env_file && svc.env_file.length > 0) {
+                lines.push("    env_file:");
+                for (const f of svc.env_file)lines.push(`      - ${f}`);
+            }
+            if (svc.environment && Object.keys(svc.environment).length > 0) {
+                lines.push("    environment:");
+                for (const [k, v] of Object.entries(svc.environment)){
+                    lines.push(`      ${k}: ${v}`);
+                }
+            }
+            if (svc.ports && svc.ports.length > 0) {
+                lines.push("    ports:");
+                for (const p of svc.ports)lines.push(`      - "${p}"`);
+            }
+            if (svc.volumes && svc.volumes.length > 0) {
+                lines.push("    volumes:");
+                for (const v of svc.volumes)lines.push(`      - ${v}`);
+            }
+            if (svc.depends_on && svc.depends_on.length > 0) {
+                lines.push("    depends_on:");
+                for (const d of svc.depends_on)lines.push(`      - ${d}`);
+            }
+        }
+        if (this._volumes.size > 0) {
+            lines.push("");
+            lines.push("volumes:");
+            for (const v of this._volumes)lines.push(`  ${v}:`);
+        }
+        return `${lines.join("\n")}\n`;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvbW9kZWxzL2NvbXBvc2UubW9kZWwudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgV0VMTF9LTk9XTl9GSUxFUyB9IGZyb20gXCIuL2NvbnN0LmpzXCI7XG5pbXBvcnQgdHlwZSB7IEtleWVkTW9kZWwgfSBmcm9tIFwiLi9zb3VyY2UtZmlsZS5qc1wiO1xuXG5leHBvcnQgaW50ZXJmYWNlIENvbXBvc2VTZXJ2aWNlIHtcblx0YnVpbGQ/OiBzdHJpbmc7XG5cdGltYWdlPzogc3RyaW5nO1xuXHRlbnZfZmlsZT86IHN0cmluZ1tdO1xuXHRlbnZpcm9ubWVudD86IFJlY29yZDxzdHJpbmcsIHN0cmluZz47XG5cdHBvcnRzPzogc3RyaW5nW107XG5cdHZvbHVtZXM/OiBzdHJpbmdbXTtcblx0Y29tbWFuZD86IHN0cmluZztcblx0cmVzdGFydD86IHN0cmluZztcblx0ZGVwZW5kc19vbj86IHN0cmluZ1tdO1xufVxuXG4vKipcbiAqIExpdmUgYnVpbGRlciBmb3IgYGRvY2tlci1jb21wb3NlLnltbGAuXG4gKlxuICogRmVhdHVyZXMgY2FsbCBgYWRkU2VydmljZWAgLyBgYWRkVm9sdW1lYCBpbiB0aGVpciBgY29uZmlndXJlYCBwaGFzZXMuXG4gKiBUaGUgZGV2Y29udGFpbmVyIGByZW5kZXJgIHBoYXNlIGNhbGxzIGByZW5kZXIoKWAgYW5kIHdyaXRlcyB0aGUgZmlsZS5cbiAqL1xuZXhwb3J0IGNsYXNzIERvY2tlckNvbXBvc2UgaW1wbGVtZW50cyBLZXllZE1vZGVsIHtcblx0cHVibGljIHJlYWRvbmx5IGtleSA9IFdFTExfS05PV05fRklMRVMuRE9DS0VSX0NPTVBPU0U7XG5cdHByaXZhdGUgcmVhZG9ubHkgX3NlcnZpY2VzOiBNYXA8c3RyaW5nLCBDb21wb3NlU2VydmljZT4gPSBuZXcgTWFwKCk7XG5cdHByaXZhdGUgcmVhZG9ubHkgX3ZvbHVtZXM6IFNldDxzdHJpbmc+ID0gbmV3IFNldCgpO1xuXG5cdHB1YmxpYyBhZGRTZXJ2aWNlKG5hbWU6IHN0cmluZywgY29uZmlnOiBDb21wb3NlU2VydmljZSk6IHRoaXMge1xuXHRcdHRoaXMuX3NlcnZpY2VzLnNldChuYW1lLCBjb25maWcpO1xuXHRcdHJldHVybiB0aGlzO1xuXHR9XG5cblx0cHVibGljIGZpbGVzKCkge1xuXHRcdHJldHVybiBbXG5cdFx0XHR7XG5cdFx0XHRcdGZpbGVQYXRoOiBcIi5kZXZjb250YWluZXIvZG9ja2VyLWNvbXBvc2UueW1sXCIsXG5cdFx0XHRcdGNvbnRlbnQ6IHRoaXMuZ2V0Q29udGVudCgpLFxuXHRcdFx0fSxcblx0XHRdO1xuXHR9XG5cblx0cHVibGljIGFkZFZvbHVtZShuYW1lOiBzdHJpbmcpOiB0aGlzIHtcblx0XHR0aGlzLl92b2x1bWVzLmFkZChuYW1lKTtcblx0XHRyZXR1cm4gdGhpcztcblx0fVxuXG5cdC8qKiBBcHBlbmQgYW4gZW52X2ZpbGUgcGF0aCB0byBhbiBleGlzdGluZyBzZXJ2aWNlLiAqL1xuXHRwdWJsaWMgYWRkRW52RmlsZShzZXJ2aWNlTmFtZTogc3RyaW5nLCBmaWxlUGF0aDogc3RyaW5nKTogdGhpcyB7XG5cdFx0Y29uc3Qgc3ZjID0gdGhpcy5fc2VydmljZXMuZ2V0KHNlcnZpY2VOYW1lKTtcblx0XHRpZiAoc3ZjKSBzdmMuZW52X2ZpbGUgPSBbLi4uKHN2Yy5lbnZfZmlsZSA/PyBbXSksIGZpbGVQYXRoXTtcblx0XHRyZXR1cm4gdGhpcztcblx0fVxuXG5cdHB1YmxpYyBnZXRDb250ZW50KCk6IHN0cmluZyB7XG5cdFx0Y29uc3QgbGluZXM6IHN0cmluZ1tdID0gW1wic2VydmljZXM6XCJdO1xuXG5cdFx0Zm9yIChjb25zdCBbbmFtZSwgc3ZjXSBvZiB0aGlzLl9zZXJ2aWNlcykge1xuXHRcdFx0bGluZXMucHVzaChgICAke25hbWV9OmApO1xuXHRcdFx0aWYgKHN2Yy5idWlsZCkgbGluZXMucHVzaChgICAgIGJ1aWxkOiAke3N2Yy5idWlsZH1gKTtcblx0XHRcdGlmIChzdmMuaW1hZ2UpIGxpbmVzLnB1c2goYCAgICBpbWFnZTogJHtzdmMuaW1hZ2V9YCk7XG5cdFx0XHRpZiAoc3ZjLmNvbW1hbmQpIGxpbmVzLnB1c2goYCAgICBjb21tYW5kOiAke3N2Yy5jb21tYW5kfWApO1xuXHRcdFx0aWYgKHN2Yy5yZXN0YXJ0KSBsaW5lcy5wdXNoKGAgICAgcmVzdGFydDogJHtzdmMucmVzdGFydH1gKTtcblxuXHRcdFx0aWYgKHN2Yy5lbnZfZmlsZSAmJiBzdmMuZW52X2ZpbGUubGVuZ3RoID4gMCkge1xuXHRcdFx0XHRsaW5lcy5wdXNoKFwiICAgIGVudl9maWxlOlwiKTtcblx0XHRcdFx0Zm9yIChjb25zdCBmIG9mIHN2Yy5lbnZfZmlsZSkgbGluZXMucHVzaChgICAgICAgLSAke2Z9YCk7XG5cdFx0XHR9XG5cblx0XHRcdGlmIChzdmMuZW52aXJvbm1lbnQgJiYgT2JqZWN0LmtleXMoc3ZjLmVudmlyb25tZW50KS5sZW5ndGggPiAwKSB7XG5cdFx0XHRcdGxpbmVzLnB1c2goXCIgICAgZW52aXJvbm1lbnQ6XCIpO1xuXHRcdFx0XHRmb3IgKGNvbnN0IFtrLCB2XSBvZiBPYmplY3QuZW50cmllcyhzdmMuZW52aXJvbm1lbnQpKSB7XG5cdFx0XHRcdFx0bGluZXMucHVzaChgICAgICAgJHtrfTogJHt2fWApO1xuXHRcdFx0XHR9XG5cdFx0XHR9XG5cblx0XHRcdGlmIChzdmMucG9ydHMgJiYgc3ZjLnBvcnRzLmxlbmd0aCA+IDApIHtcblx0XHRcdFx0bGluZXMucHVzaChcIiAgICBwb3J0czpcIik7XG5cdFx0XHRcdGZvciAoY29uc3QgcCBvZiBzdmMucG9ydHMpIGxpbmVzLnB1c2goYCAgICAgIC0gXCIke3B9XCJgKTtcblx0XHRcdH1cblxuXHRcdFx0aWYgKHN2Yy52b2x1bWVzICYmIHN2Yy52b2x1bWVzLmxlbmd0aCA+IDApIHtcblx0XHRcdFx0bGluZXMucHVzaChcIiAgICB2b2x1bWVzOlwiKTtcblx0XHRcdFx0Zm9yIChjb25zdCB2IG9mIHN2Yy52b2x1bWVzKSBsaW5lcy5wdXNoKGAgICAgICAtICR7dn1gKTtcblx0XHRcdH1cblxuXHRcdFx0aWYgKHN2Yy5kZXBlbmRzX29uICYmIHN2Yy5kZXBlbmRzX29uLmxlbmd0aCA+IDApIHtcblx0XHRcdFx0bGluZXMucHVzaChcIiAgICBkZXBlbmRzX29uOlwiKTtcblx0XHRcdFx0Zm9yIChjb25zdCBkIG9mIHN2Yy5kZXBlbmRzX29uKSBsaW5lcy5wdXNoKGAgICAgICAtICR7ZH1gKTtcblx0XHRcdH1cblx0XHR9XG5cblx0XHRpZiAodGhpcy5fdm9sdW1lcy5zaXplID4gMCkge1xuXHRcdFx0bGluZXMucHVzaChcIlwiKTtcblx0XHRcdGxpbmVzLnB1c2goXCJ2b2x1bWVzOlwiKTtcblx0XHRcdGZvciAoY29uc3QgdiBvZiB0aGlzLl92b2x1bWVzKSBsaW5lcy5wdXNoKGAgICR7dn06YCk7XG5cdFx0fVxuXG5cdFx0cmV0dXJuIGAke2xpbmVzLmpvaW4oXCJcXG5cIil9XFxuYDtcblx0fVxufVxuIl0sIm5hbWVzIjpbIkRvY2tlckNvbXBvc2UiLCJrZXkiLCJXRUxMX0tOT1dOX0ZJTEVTIiwiRE9DS0VSX0NPTVBPU0UiLCJfc2VydmljZXMiLCJNYXAiLCJfdm9sdW1lcyIsIlNldCIsImFkZFNlcnZpY2UiLCJuYW1lIiwiY29uZmlnIiwic2V0IiwiZmlsZXMiLCJmaWxlUGF0aCIsImNvbnRlbnQiLCJnZXRDb250ZW50IiwiYWRkVm9sdW1lIiwiYWRkIiwiYWRkRW52RmlsZSIsInNlcnZpY2VOYW1lIiwic3ZjIiwiZ2V0IiwiZW52X2ZpbGUiLCJsaW5lcyIsInB1c2giLCJidWlsZCIsImltYWdlIiwiY29tbWFuZCIsInJlc3RhcnQiLCJsZW5ndGgiLCJmIiwiZW52aXJvbm1lbnQiLCJPYmplY3QiLCJrZXlzIiwiayIsInYiLCJlbnRyaWVzIiwicG9ydHMiLCJwIiwidm9sdW1lcyIsImRlcGVuZHNfb24iLCJkIiwic2l6ZSIsImpvaW4iXSwibWFwcGluZ3MiOiI7Ozs7K0JBcUJhQTs7O2VBQUFBOzs7dUJBckJvQjtBQXFCMUIsTUFBTUE7SUFDSUMsTUFBTUMsdUJBQWdCLENBQUNDLGNBQWMsQ0FBQztJQUNyQ0MsWUFBeUMsSUFBSUMsTUFBTTtJQUNuREMsV0FBd0IsSUFBSUMsTUFBTTtJQUU1Q0MsV0FBV0MsSUFBWSxFQUFFQyxNQUFzQixFQUFRO1FBQzdELElBQUksQ0FBQ04sU0FBUyxDQUFDTyxHQUFHLENBQUNGLE1BQU1DO1FBQ3pCLE9BQU8sSUFBSTtJQUNaO0lBRU9FLFFBQVE7UUFDZCxPQUFPO1lBQ047Z0JBQ0NDLFVBQVU7Z0JBQ1ZDLFNBQVMsSUFBSSxDQUFDQyxVQUFVO1lBQ3pCO1NBQ0E7SUFDRjtJQUVPQyxVQUFVUCxJQUFZLEVBQVE7UUFDcEMsSUFBSSxDQUFDSCxRQUFRLENBQUNXLEdBQUcsQ0FBQ1I7UUFDbEIsT0FBTyxJQUFJO0lBQ1o7SUFFQSxvREFBb0QsR0FDcEQsQUFBT1MsV0FBV0MsV0FBbUIsRUFBRU4sUUFBZ0IsRUFBUTtRQUM5RCxNQUFNTyxNQUFNLElBQUksQ0FBQ2hCLFNBQVMsQ0FBQ2lCLEdBQUcsQ0FBQ0Y7UUFDL0IsSUFBSUMsS0FBS0EsSUFBSUUsUUFBUSxHQUFHO2VBQUtGLElBQUlFLFFBQVEsSUFBSSxFQUFFO1lBQUdUO1NBQVM7UUFDM0QsT0FBTyxJQUFJO0lBQ1o7SUFFT0UsYUFBcUI7UUFDM0IsTUFBTVEsUUFBa0I7WUFBQztTQUFZO1FBRXJDLEtBQUssTUFBTSxDQUFDZCxNQUFNVyxJQUFJLElBQUksSUFBSSxDQUFDaEIsU0FBUyxDQUFFO1lBQ3pDbUIsTUFBTUMsSUFBSSxDQUFDLENBQUMsRUFBRSxFQUFFZixLQUFLLENBQUMsQ0FBQztZQUN2QixJQUFJVyxJQUFJSyxLQUFLLEVBQUVGLE1BQU1DLElBQUksQ0FBQyxDQUFDLFdBQVcsRUFBRUosSUFBSUssS0FBSyxFQUFFO1lBQ25ELElBQUlMLElBQUlNLEtBQUssRUFBRUgsTUFBTUMsSUFBSSxDQUFDLENBQUMsV0FBVyxFQUFFSixJQUFJTSxLQUFLLEVBQUU7WUFDbkQsSUFBSU4sSUFBSU8sT0FBTyxFQUFFSixNQUFNQyxJQUFJLENBQUMsQ0FBQyxhQUFhLEVBQUVKLElBQUlPLE9BQU8sRUFBRTtZQUN6RCxJQUFJUCxJQUFJUSxPQUFPLEVBQUVMLE1BQU1DLElBQUksQ0FBQyxDQUFDLGFBQWEsRUFBRUosSUFBSVEsT0FBTyxFQUFFO1lBRXpELElBQUlSLElBQUlFLFFBQVEsSUFBSUYsSUFBSUUsUUFBUSxDQUFDTyxNQUFNLEdBQUcsR0FBRztnQkFDNUNOLE1BQU1DLElBQUksQ0FBQztnQkFDWCxLQUFLLE1BQU1NLEtBQUtWLElBQUlFLFFBQVEsQ0FBRUMsTUFBTUMsSUFBSSxDQUFDLENBQUMsUUFBUSxFQUFFTSxHQUFHO1lBQ3hEO1lBRUEsSUFBSVYsSUFBSVcsV0FBVyxJQUFJQyxPQUFPQyxJQUFJLENBQUNiLElBQUlXLFdBQVcsRUFBRUYsTUFBTSxHQUFHLEdBQUc7Z0JBQy9ETixNQUFNQyxJQUFJLENBQUM7Z0JBQ1gsS0FBSyxNQUFNLENBQUNVLEdBQUdDLEVBQUUsSUFBSUgsT0FBT0ksT0FBTyxDQUFDaEIsSUFBSVcsV0FBVyxFQUFHO29CQUNyRFIsTUFBTUMsSUFBSSxDQUFDLENBQUMsTUFBTSxFQUFFVSxFQUFFLEVBQUUsRUFBRUMsR0FBRztnQkFDOUI7WUFDRDtZQUVBLElBQUlmLElBQUlpQixLQUFLLElBQUlqQixJQUFJaUIsS0FBSyxDQUFDUixNQUFNLEdBQUcsR0FBRztnQkFDdENOLE1BQU1DLElBQUksQ0FBQztnQkFDWCxLQUFLLE1BQU1jLEtBQUtsQixJQUFJaUIsS0FBSyxDQUFFZCxNQUFNQyxJQUFJLENBQUMsQ0FBQyxTQUFTLEVBQUVjLEVBQUUsQ0FBQyxDQUFDO1lBQ3ZEO1lBRUEsSUFBSWxCLElBQUltQixPQUFPLElBQUluQixJQUFJbUIsT0FBTyxDQUFDVixNQUFNLEdBQUcsR0FBRztnQkFDMUNOLE1BQU1DLElBQUksQ0FBQztnQkFDWCxLQUFLLE1BQU1XLEtBQUtmLElBQUltQixPQUFPLENBQUVoQixNQUFNQyxJQUFJLENBQUMsQ0FBQyxRQUFRLEVBQUVXLEdBQUc7WUFDdkQ7WUFFQSxJQUFJZixJQUFJb0IsVUFBVSxJQUFJcEIsSUFBSW9CLFVBQVUsQ0FBQ1gsTUFBTSxHQUFHLEdBQUc7Z0JBQ2hETixNQUFNQyxJQUFJLENBQUM7Z0JBQ1gsS0FBSyxNQUFNaUIsS0FBS3JCLElBQUlvQixVQUFVLENBQUVqQixNQUFNQyxJQUFJLENBQUMsQ0FBQyxRQUFRLEVBQUVpQixHQUFHO1lBQzFEO1FBQ0Q7UUFFQSxJQUFJLElBQUksQ0FBQ25DLFFBQVEsQ0FBQ29DLElBQUksR0FBRyxHQUFHO1lBQzNCbkIsTUFBTUMsSUFBSSxDQUFDO1lBQ1hELE1BQU1DLElBQUksQ0FBQztZQUNYLEtBQUssTUFBTVcsS0FBSyxJQUFJLENBQUM3QixRQUFRLENBQUVpQixNQUFNQyxJQUFJLENBQUMsQ0FBQyxFQUFFLEVBQUVXLEVBQUUsQ0FBQyxDQUFDO1FBQ3BEO1FBRUEsT0FBTyxHQUFHWixNQUFNb0IsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO0lBQy9CO0FBQ0QifQ==

package/commonjs/src/models/config-yaml.model.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ConfigYaml", {
+    enumerable: true,
+    get: function() {
+        return ConfigYaml;
+    }
+});
+class ConfigYaml {
+    key;
+    filePath;
+    _sections = [];
+    constructor(key, filePath, baseContent){
+        this.key = key;
+        this.filePath = filePath;
+        this._sections.push(baseContent);
+    }
+    addSection(yaml) {
+        this._sections.push(yaml);
+        return this;
+    }
+    files() {
+        return [
+            {
+                filePath: this.filePath,
+                content: this._sections.join("\n")
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/models/const.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WELL_KNOWN_FILES", {
+    enumerable: true,
+    get: function() {
+        return WELL_KNOWN_FILES;
+    }
+});
+const WELL_KNOWN_FILES = {
+    VSCODE_SETTINGS: "VSCODE_SETTINGS",
+    LAUNCH_JSON: "LAUNCH_JSON",
+    DOCKER_COMPOSE: "DOCKER_COMPOSE",
+    DEVCONTAINER_JSON: "DEVCONTAINER_JSON",
+    DOCKERFILE: "DOCKERFILE",
+    PACKAGE_JSON: "PACKAGE_JSON",
+    API_PACKAGE_JSON: "API_PACKAGE_JSON",
+    TSCONFIG: "TSCONFIG",
+    MAIN_TS: "MAIN_TS",
+    CONTROLLER_TS: "CONTROLLER_TS",
+    CONFIG_YAML: "CONFIG_YAML",
+    CONFIG_DEV_YAML: "CONFIG_DEV_YAML",
+    GITIGNORE: "GITIGNORE",
+    AUTH_CONFIG: "AUTH_CONFIG",
+    ENV_FILE: "ENV_FILE"
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvbW9kZWxzL2NvbnN0LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBXRUxMX0tOT1dOX0ZJTEVTID0ge1xuXHRWU0NPREVfU0VUVElOR1M6IFwiVlNDT0RFX1NFVFRJTkdTXCIsXG5cdExBVU5DSF9KU09OOiBcIkxBVU5DSF9KU09OXCIsXG5cdERPQ0tFUl9DT01QT1NFOiBcIkRPQ0tFUl9DT01QT1NFXCIsXG5cdERFVkNPTlRBSU5FUl9KU09OOiBcIkRFVkNPTlRBSU5FUl9KU09OXCIsXG5cdERPQ0tFUkZJTEU6IFwiRE9DS0VSRklMRVwiLFxuXHRQQUNLQUdFX0pTT046IFwiUEFDS0FHRV9KU09OXCIsXG5cdEFQSV9QQUNLQUdFX0pTT046IFwiQVBJX1BBQ0tBR0VfSlNPTlwiLFxuXHRUU0NPTkZJRzogXCJUU0NPTkZJR1wiLFxuXHRNQUlOX1RTOiBcIk1BSU5fVFNcIixcblx0Q09OVFJPTExFUl9UUzogXCJDT05UUk9MTEVSX1RTXCIsXG5cdENPTkZJR19ZQU1MOiBcIkNPTkZJR19ZQU1MXCIsXG5cdENPTkZJR19ERVZfWUFNTDogXCJDT05GSUdfREVWX1lBTUxcIixcblx0R0lUSUdOT1JFOiBcIkdJVElHTk9SRVwiLFxuXHRBVVRIX0NPTkZJRzogXCJBVVRIX0NPTkZJR1wiLFxuXHRFTlZfRklMRTogXCJFTlZfRklMRVwiLFxufTtcbiJdLCJuYW1lcyI6WyJXRUxMX0tOT1dOX0ZJTEVTIiwiVlNDT0RFX1NFVFRJTkdTIiwiTEFVTkNIX0pTT04iLCJET0NLRVJfQ09NUE9TRSIsIkRFVkNPTlRBSU5FUl9KU09OIiwiRE9DS0VSRklMRSIsIlBBQ0tBR0VfSlNPTiIsIkFQSV9QQUNLQUdFX0pTT04iLCJUU0NPTkZJRyIsIk1BSU5fVFMiLCJDT05UUk9MTEVSX1RTIiwiQ09ORklHX1lBTUwiLCJDT05GSUdfREVWX1lBTUwiLCJHSVRJR05PUkUiLCJBVVRIX0NPTkZJRyIsIkVOVl9GSUxFIl0sIm1hcHBpbmdzIjoiOzs7OytCQUFhQTs7O2VBQUFBOzs7QUFBTixNQUFNQSxtQkFBbUI7SUFDL0JDLGlCQUFpQjtJQUNqQkMsYUFBYTtJQUNiQyxnQkFBZ0I7SUFDaEJDLG1CQUFtQjtJQUNuQkMsWUFBWTtJQUNaQyxjQUFjO0lBQ2RDLGtCQUFrQjtJQUNsQkMsVUFBVTtJQUNWQyxTQUFTO0lBQ1RDLGVBQWU7SUFDZkMsYUFBYTtJQUNiQyxpQkFBaUI7SUFDakJDLFdBQVc7SUFDWEMsYUFBYTtJQUNiQyxVQUFVO0FBQ1gifQ==

package/commonjs/src/models/container-image.model.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DockerfileModel", {
+    enumerable: true,
+    get: function() {
+        return DockerfileModel;
+    }
+});
+const _const = require("./const.js");
+// Everything before the final USER instruction. Features insert RUN steps here.
+const DOCKERFILE_BASE = `FROM node:24
+
+ARG USERNAME=node
+
+# System tools: jq + ripgrep for scripting/search, python3 for AI tooling,
+# gh for GitHub workflows, curl/gnupg for package sources.
+RUN apt-get update \\
+    && apt-get install -y --no-install-recommends ca-certificates curl gnupg jq ripgrep python3 \\
+    && curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg -o /usr/share/keyrings/githubcli-archive-keyring.gpg \\
+    && chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg \\
+    && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" > /etc/apt/sources.list.d/github-cli.list \\
+    && apt-get update \\
+    && apt-get install -y --no-install-recommends gh \\
+    && rm -rf /var/lib/apt/lists/*
+
+RUN npm install --global npm@latest \\
+    && npm add --global pnpm@10
+
+RUN mkdir -p /home/\${USERNAME}/.config/pnpm /home/\${USERNAME}/.pnpm-store \\
+    && chown -R \${USERNAME}:\${USERNAME} /home/\${USERNAME}/.config /home/\${USERNAME}/.pnpm-store \\
+    && printf "store-dir=/home/\${USERNAME}/.pnpm-store\\n" > /home/\${USERNAME}/.config/pnpm/rc
+
+# Pre-create workspace node_modules so the named volume mount is owned by the user
+RUN mkdir -p /workspace/node_modules && chown \${USERNAME}:\${USERNAME} /workspace/node_modules
+
+RUN mkdir /commandhistory && touch /commandhistory/.bash_history \\
+    && chown -R \${USERNAME} /commandhistory
+
+RUN SNIPPET="export PROMPT_COMMAND='history -a' && export HISTFILE=/commandhistory/.bash_history" \\
+    && echo "$SNIPPET" >> "/home/\${USERNAME}/.bashrc"
+
+# VS Code js-debug bug: bootloader.js in workspaceStorage is only created when
+# the user manually toggles Auto Attach settings. On a fresh container it is
+# missing, which crashes every Node command. Fix: if the injected path is
+# missing, substitute the stable bootloader from the VS Code server extension
+# directory (always present once the server is installed).
+RUN cat <<'EOF' >> "/home/\${USERNAME}/.bashrc"
+if [[ -n "\${NODE_OPTIONS:-}" && "\${NODE_OPTIONS}" == *"bootloader.js"* ]]; then
+    _bootloader_path="$(printf '%s\\n' "$NODE_OPTIONS" | sed -n 's/.*--require[= ]\\([^[:space:]]*bootloader\\.js\\).*/\\1/p')"
+    if [[ -n "\${_bootloader_path}" && ! -f "\${_bootloader_path}" ]]; then
+        _stable_bootloader="$(find /vscode/vscode-server /home/node/.vscode-server/extensions -name "bootloader.js" -path "*/ms-vscode.js-debug/*" 2>/dev/null | head -1)"
+        if [[ -n "\${_stable_bootloader}" ]]; then
+            NODE_OPTIONS="\${NODE_OPTIONS//\${_bootloader_path}/\${_stable_bootloader}}"
+        else
+            NODE_OPTIONS="$(printf '%s\\n' "$NODE_OPTIONS" | sed -E 's#(^| )--require(=| )[[:graph:]]*bootloader\\.js( |$)# #g; s#  +# #g; s#^ ##; s# $##')"
+            unset VSCODE_INSPECTOR_OPTIONS
+        fi
+        export NODE_OPTIONS
+        if [[ -z "$NODE_OPTIONS" ]]; then
+            unset NODE_OPTIONS
+        fi
+    fi
+    unset _bootloader_path _stable_bootloader
+fi
+EOF
+`;
+const DOCKERFILE_USER = `\nUSER \${USERNAME}\n`;
+class DockerfileModel {
+    key = _const.WELL_KNOWN_FILES.DOCKERFILE;
+    _runSteps = [];
+    /** Append a RUN instruction (pass the command, not the RUN keyword). */ addRunStep(cmd) {
+        this._runSteps.push(cmd);
+        return this;
+    }
+    files() {
+        const extras = this._runSteps.length > 0 ? `\n${this._runSteps.map((s)=>`RUN ${s}`).join("\n\n")}\n` : "";
+        return [
+            {
+                filePath: ".devcontainer/Dockerfile",
+                content: DOCKERFILE_BASE + extras + DOCKERFILE_USER
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/models/dev-container.model.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DevContainer", {
+    enumerable: true,
+    get: function() {
+        return DevContainer;
+    }
+});
+const _const = require("./const.js");
+class DevContainer {
+    key = _const.WELL_KNOWN_FILES.DEVCONTAINER_JSON;
+    _extensions = [];
+    _ports = [];
+    _mounts;
+    _postStartCommand;
+    _useCompose = false;
+    constructor(){
+        this._mounts = [
+            "source=..,target=/workspace,type=bind,consistency=cached"
+        ];
+        this.forwardPort(3000);
+    }
+    addExtension(...ids) {
+        this._extensions.push(...ids);
+        return this;
+    }
+    forwardPort(...ports) {
+        this._ports.push(...ports);
+        return this;
+    }
+    setPostStartCommand(cmd) {
+        this._postStartCommand = cmd;
+        return this;
+    }
+    useCompose() {
+        this._useCompose = true;
+        return this;
+    }
+    files() {
+        const config = {};
+        if (this._useCompose) {
+            config.dockerComposeFile = "docker-compose.yml";
+            config.service = "devcontainer";
+            config.workspaceFolder = "/workspace";
+        }
+        if (this._mounts) {
+            config.mounts = this._mounts;
+        }
+        if (this._extensions.length > 0) {
+            config.customizations = {
+                vscode: {
+                    extensions: this._extensions
+                }
+            };
+        }
+        if (this._ports.length > 0) {
+            config.forwardPorts = this._ports;
+        }
+        if (this._postStartCommand) {
+            config.postStartCommand = this._postStartCommand;
+        }
+        return [
+            {
+                filePath: ".devcontainer/devcontainer.json",
+                content: JSON.stringify(config, null, 2)
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/models/env-file.model.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EnvFile", {
+    enumerable: true,
+    get: function() {
+        return EnvFile;
+    }
+});
+const _const = require("./const.js");
+class EnvFile {
+    key = _const.WELL_KNOWN_FILES.ENV_FILE;
+    _entries = new Map();
+    addEntry(key, value) {
+        this._entries.set(key, value);
+        return this;
+    }
+    files() {
+        if (this._entries.size === 0) return [];
+        const content = [
+            ...this._entries.entries()
+        ].map(([k, v])=>`${k}=${v}`).join("\n") + "\n";
+        return [
+            {
+                filePath: ".env",
+                content
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/models/gitignore.model.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Gitignore", {
+    enumerable: true,
+    get: function() {
+        return Gitignore;
+    }
+});
+const _const = require("./const.js");
+class Gitignore {
+    key = _const.WELL_KNOWN_FILES.GITIGNORE;
+    ignoreList = [
+        "node_modules",
+        "dist",
+        ".pnpm-store",
+        ".env",
+        ".env.local",
+        ".DS_Store"
+    ];
+    files() {
+        return [
+            {
+                filePath: ".gitignore",
+                content: this.ignoreList.join("\n")
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvbW9kZWxzL2dpdGlnbm9yZS5tb2RlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBXRUxMX0tOT1dOX0ZJTEVTIH0gZnJvbSBcIi4vY29uc3QuanNcIjtcbmltcG9ydCB0eXBlIHsgS2V5ZWRNb2RlbCwgU291cmNlRmlsZSB9IGZyb20gXCIuL3NvdXJjZS1maWxlLmpzXCI7XG5cbmV4cG9ydCBjbGFzcyBHaXRpZ25vcmUgaW1wbGVtZW50cyBLZXllZE1vZGVsIHtcblx0cHVibGljIHJlYWRvbmx5IGtleSA9IFdFTExfS05PV05fRklMRVMuR0lUSUdOT1JFO1xuXHRwcml2YXRlIGlnbm9yZUxpc3QgPSBbXG5cdFx0XCJub2RlX21vZHVsZXNcIixcblx0XHRcImRpc3RcIixcblx0XHRcIi5wbnBtLXN0b3JlXCIsXG5cdFx0XCIuZW52XCIsXG5cdFx0XCIuZW52LmxvY2FsXCIsXG5cdFx0XCIuRFNfU3RvcmVcIixcblx0XTtcblxuXHRwdWJsaWMgZmlsZXMoKTogU291cmNlRmlsZVtdIHtcblx0XHRyZXR1cm4gW1xuXHRcdFx0e1xuXHRcdFx0XHRmaWxlUGF0aDogXCIuZ2l0aWdub3JlXCIsXG5cdFx0XHRcdGNvbnRlbnQ6IHRoaXMuaWdub3JlTGlzdC5qb2luKFwiXFxuXCIpLFxuXHRcdFx0fSxcblx0XHRdO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiR2l0aWdub3JlIiwia2V5IiwiV0VMTF9LTk9XTl9GSUxFUyIsIkdJVElHTk9SRSIsImlnbm9yZUxpc3QiLCJmaWxlcyIsImZpbGVQYXRoIiwiY29udGVudCIsImpvaW4iXSwibWFwcGluZ3MiOiI7Ozs7K0JBR2FBOzs7ZUFBQUE7Ozt1QkFIb0I7QUFHMUIsTUFBTUE7SUFDSUMsTUFBTUMsdUJBQWdCLENBQUNDLFNBQVMsQ0FBQztJQUN6Q0MsYUFBYTtRQUNwQjtRQUNBO1FBQ0E7UUFDQTtRQUNBO1FBQ0E7S0FDQSxDQUFDO0lBRUtDLFFBQXNCO1FBQzVCLE9BQU87WUFDTjtnQkFDQ0MsVUFBVTtnQkFDVkMsU0FBUyxJQUFJLENBQUNILFVBQVUsQ0FBQ0ksSUFBSSxDQUFDO1lBQy9CO1NBQ0E7SUFDRjtBQUNEIn0=

package/commonjs/src/models/launch-json.model.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LaunchJson", {
+    enumerable: true,
+    get: function() {
+        return LaunchJson;
+    }
+});
+const _const = require("./const.js");
+class LaunchJson {
+    key = _const.WELL_KNOWN_FILES.LAUNCH_JSON;
+    files() {
+        return [
+            {
+                filePath: ".vscode/launch.json",
+                content: JSON.stringify({
+                    version: "0.2.0",
+                    configurations: [
+                        {
+                            name: "Build",
+                            type: "node",
+                            request: "launch",
+                            runtimeExecutable: "pnpm",
+                            runtimeArgs: [
+                                "build"
+                            ],
+                            console: "integratedTerminal",
+                            // biome-ignore lint/suspicious/noTemplateCurlyInString: VS Code variable
+                            cwd: "${workspaceFolder}"
+                        },
+                        {
+                            name: "Serve / Dev",
+                            type: "node",
+                            request: "launch",
+                            runtimeExecutable: "pnpm",
+                            runtimeArgs: [
+                                "dev"
+                            ],
+                            console: "integratedTerminal",
+                            // biome-ignore lint/suspicious/noTemplateCurlyInString: VS Code variable
+                            cwd: "${workspaceFolder}"
+                        }
+                    ]
+                }, null, 2)
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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