@decohere/scaffold 0.0.1-dev.18 → 0.0.1-dev.80

package/commonjs/src/version.js

@@ -0,0 +1,57 @@
+"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 CREATE_IMAGE_REPOSITORY () {
+        return CREATE_IMAGE_REPOSITORY;
+    },
+    get CREATE_VERSION () {
+        return CREATE_VERSION;
+    },
+    get DEVCONTAINER_IMAGE_REPOSITORY () {
+        return DEVCONTAINER_IMAGE_REPOSITORY;
+    }
+});
+const _nodemodule = require("node:module");
+const _nodepath = require("node:path");
+const _nodeurl = require("node:url");
+const _require = (0, _nodemodule.createRequire)(require("url").pathToFileURL(__filename).toString());
+const DEFAULT_CREATE_VERSION = "0.0.1-dev";
+const DEFAULT_CREATE_IMAGE_REPOSITORY = "ghcr.io/typesmiths/decohere/create";
+const DEFAULT_DEVCONTAINER_IMAGE_REPOSITORY = "ghcr.io/typesmiths/decohere/devcontainer";
+function resolveCreateMetadata() {
+    let dir = (0, _nodepath.dirname)((0, _nodeurl.fileURLToPath)(require("url").pathToFileURL(__filename).toString()));
+    for(let i = 0; i < 5; i++){
+        try {
+            const pkg = _require((0, _nodepath.join)(dir, "package.json"));
+            if (pkg.name === "@decohere/scaffold") {
+                return {
+                    version: pkg.version ?? DEFAULT_CREATE_VERSION,
+                    imageRepository: pkg.decohere?.dockerImageRepository ?? DEFAULT_CREATE_IMAGE_REPOSITORY,
+                    devcontainerImageRepository: pkg.decohere?.devcontainerImageRepository ?? DEFAULT_DEVCONTAINER_IMAGE_REPOSITORY
+                };
+            }
+        } catch  {}
+        const parent = (0, _nodepath.dirname)(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return {
+        version: DEFAULT_CREATE_VERSION,
+        imageRepository: DEFAULT_CREATE_IMAGE_REPOSITORY,
+        devcontainerImageRepository: DEFAULT_DEVCONTAINER_IMAGE_REPOSITORY
+    };
+}
+const createMetadata = resolveCreateMetadata();
+const CREATE_VERSION = createMetadata.version;
+const CREATE_IMAGE_REPOSITORY = createMetadata.imageRepository;
+const DEVCONTAINER_IMAGE_REPOSITORY = createMetadata.devcontainerImageRepository;
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/webapi/api-name.js

@@ -0,0 +1,95 @@
+"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 API_NAME_PATTERN () {
+        return API_NAME_PATTERN;
+    },
+    get CreateCliError () {
+        return CreateCliError;
+    },
+    get apiEnvPrefix () {
+        return apiEnvPrefix;
+    },
+    get apiNameFromProjectDir () {
+        return apiNameFromProjectDir;
+    },
+    get assertValidApiName () {
+        return assertValidApiName;
+    },
+    get isDecohereWorkspace () {
+        return isDecohereWorkspace;
+    },
+    get listExistingApiNames () {
+        return listExistingApiNames;
+    },
+    get parseApiNames () {
+        return parseApiNames;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodepath = require("node:path");
+const _const = require("./const.js");
+const API_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+class CreateCliError extends Error {
+    constructor(message){
+        super(message);
+        this.name = "CreateCliError";
+    }
+}
+function assertValidApiName(name) {
+    if (!API_NAME_PATTERN.test(name)) {
+        throw new CreateCliError(`Invalid API name "${name}". Use a lowercase slug starting with a letter, then letters, digits, or hyphens (e.g. billing).`);
+    }
+}
+function parseApiNames(raw) {
+    const names = raw != null && raw.length > 0 ? [
+        ...raw
+    ] : [
+        _const.DEFAULT_WEBAPI_NAME
+    ];
+    const seen = new Set();
+    for (const name of names){
+        assertValidApiName(name);
+        if (seen.has(name)) {
+            throw new CreateCliError(`Duplicate API name "${name}".`);
+        }
+        seen.add(name);
+    }
+    return names;
+}
+function isDecohereWorkspace(dir) {
+    try {
+        const pkg = JSON.parse((0, _nodefs.readFileSync)((0, _nodepath.join)(dir, "package.json"), "utf8"));
+        const build = pkg.scripts?.build;
+        return typeof build === "string" && build.includes("forge");
+    } catch  {
+        return false;
+    }
+}
+function listExistingApiNames(dir) {
+    const projectsDir = (0, _nodepath.join)(dir, "projects");
+    try {
+        return (0, _nodefs.readdirSync)(projectsDir, {
+            withFileTypes: true
+        }).filter((entry)=>entry.isDirectory() && (0, _nodefs.existsSync)((0, _nodepath.join)(projectsDir, entry.name, "package.json"))).map((entry)=>entry.name).sort();
+    } catch  {
+        return [];
+    }
+}
+function apiEnvPrefix(apiName) {
+    return apiName.replace(/-/g, "_").toUpperCase();
+}
+function apiNameFromProjectDir(dir) {
+    const slash = dir.lastIndexOf("/");
+    return slash >= 0 ? dir.slice(slash + 1) : dir;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/webapi/cli-options.js

@@ -0,0 +1,101 @@
+"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 addWebapiFeatureOptions () {
+        return addWebapiFeatureOptions;
+    },
+    get collectName () {
+        return collectName;
+    },
+    get runScaffoldApi () {
+        return runScaffoldApi;
+    },
+    get toApiOptions () {
+        return toApiOptions;
+    }
+});
+const _resolvetargetdir = require("../resolve-target-dir.js");
+const _apiname = require("./api-name.js");
+const _createapi = require("./create-api.js");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function collectName(value, previous) {
+    previous.push(value);
+    return previous;
+}
+function addWebapiFeatureOptions(cmd) {
+    return cmd.option("--database <provider>", "Database provider: none | postgres/typeorm").option("--auth <provider>", "Auth provider: none | auth0").option("--postman <provider>", "Postman provider: none | local | api").option("-y, --yes", "Install dependencies without prompting").option("--install <mode>", "Dependency install mode: ask | yes | no", "ask");
+}
+function toApiOptions(directory, opts, extra = {}) {
+    const installMode = String(opts.install ?? "ask").toLowerCase();
+    const names = Array.isArray(opts.name) ? opts.name : typeof opts.name === "string" ? [
+        opts.name
+    ] : extra.names;
+    return {
+        d: (0, _resolvetargetdir.resolveTargetDir)(directory, typeof opts.d === "string" ? opts.d : undefined),
+        databaseProvider: opts.database,
+        authProvider: opts.auth,
+        postmanProvider: opts.postman,
+        installDependencies: opts.yes === true ? "yes" : installMode === "yes" || installMode === "no" ? installMode : undefined,
+        names,
+        ...extra
+    };
+}
+async function runScaffoldApi(normalized) {
+    (0, _apiname.parseApiNames)(normalized.names);
+    const { closePrompt } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../domain/prompt.js")));
+    try {
+        await (0, _createapi.scaffoldApi)(normalized);
+    } finally{
+        closePrompt();
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/webapi/const.js

@@ -0,0 +1,50 @@
+/** Default API project slug when `--name` is omitted. */ "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 DEFAULT_WEBAPI_NAME () {
+        return DEFAULT_WEBAPI_NAME;
+    },
+    get WEBAPI_PROJECT_DIR () {
+        return WEBAPI_PROJECT_DIR;
+    },
+    get WEBAPI_RELEASE_ENTRY () {
+        return WEBAPI_RELEASE_ENTRY;
+    },
+    get webapiPackageName () {
+        return webapiPackageName;
+    },
+    get webapiPort () {
+        return webapiPort;
+    },
+    get webapiProjectDir () {
+        return webapiProjectDir;
+    },
+    get webapiReleaseEntry () {
+        return webapiReleaseEntry;
+    }
+});
+const DEFAULT_WEBAPI_NAME = "api";
+function webapiProjectDir(name) {
+    return `projects/${name}`;
+}
+function webapiReleaseEntry(name) {
+    return `dist/release/${webapiProjectDir(name)}/es6/src/main.js`;
+}
+function webapiPackageName(workspaceName, apiName) {
+    return `@${workspaceName}/${apiName}`;
+}
+function webapiPort(index) {
+    return 3000 + index;
+}
+const WEBAPI_PROJECT_DIR = webapiProjectDir(DEFAULT_WEBAPI_NAME);
+const WEBAPI_RELEASE_ENTRY = webapiReleaseEntry(DEFAULT_WEBAPI_NAME);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy93ZWJhcGkvY29uc3QudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqIERlZmF1bHQgQVBJIHByb2plY3Qgc2x1ZyB3aGVuIGAtLW5hbWVgIGlzIG9taXR0ZWQuICovXG5leHBvcnQgY29uc3QgREVGQVVMVF9XRUJBUElfTkFNRSA9IFwiYXBpXCI7XG5cbi8qKiBSZWxhdGl2ZSBwYXRoIG9mIGFuIEFQSSBwcm9qZWN0IGluc2lkZSB0aGUgbW9ub3JlcG8uICovXG5leHBvcnQgZnVuY3Rpb24gd2ViYXBpUHJvamVjdERpcihuYW1lOiBzdHJpbmcpOiBzdHJpbmcge1xuXHRyZXR1cm4gYHByb2plY3RzLyR7bmFtZX1gO1xufVxuXG4vKipcbiAqIEZvcmdlIHJlbGVhc2UgZW50cnkgZm9yIGEgc2NhZmZvbGRlZCBBUEkgKGBwYWNrOiB0cnVlYCDihpIgcGVyLXRhcmdldCBvdXREaXIpLlxuICogS2VlcCBpbiBzeW5jIHdpdGggcm9vdCBgcGFja2FnZS5qc29uYCBgXCJzdGFydFwiYCAvIGBcInN0YXJ0OjxuYW1lPlwiYCBhbmQgRG9ja2VyZmlsZXMuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB3ZWJhcGlSZWxlYXNlRW50cnkobmFtZTogc3RyaW5nKTogc3RyaW5nIHtcblx0cmV0dXJuIGBkaXN0L3JlbGVhc2UvJHt3ZWJhcGlQcm9qZWN0RGlyKG5hbWUpfS9lczYvc3JjL21haW4uanNgO1xufVxuXG4vKiogbnBtIHBhY2thZ2UgbmFtZSBmb3IgYSBzY2FmZm9sZGVkIEFQSSAoYGZsdXggc2VydmUgLS1wcm9qZWN0YCkuICovXG5leHBvcnQgZnVuY3Rpb24gd2ViYXBpUGFja2FnZU5hbWUod29ya3NwYWNlTmFtZTogc3RyaW5nLCBhcGlOYW1lOiBzdHJpbmcpOiBzdHJpbmcge1xuXHRyZXR1cm4gYEAke3dvcmtzcGFjZU5hbWV9LyR7YXBpTmFtZX1gO1xufVxuXG4vKiogTG9jYWwgbGlzdGVuIHBvcnQgZm9yIHRoZSBudGggQVBJICgwLWJhc2VkKS4gUHJvZHVjdGlvbiB1c2VzIGBQT1JUYC4gKi9cbmV4cG9ydCBmdW5jdGlvbiB3ZWJhcGlQb3J0KGluZGV4OiBudW1iZXIpOiBudW1iZXIge1xuXHRyZXR1cm4gMzAwMCArIGluZGV4O1xufVxuXG4vKiogQGRlcHJlY2F0ZWQgVXNlIGB3ZWJhcGlQcm9qZWN0RGlyKG5hbWUpYC4gRGVmYXVsdCBwYXRoIGZvciB0aGUgZmlyc3QgQVBJLiAqL1xuZXhwb3J0IGNvbnN0IFdFQkFQSV9QUk9KRUNUX0RJUiA9IHdlYmFwaVByb2plY3REaXIoREVGQVVMVF9XRUJBUElfTkFNRSk7XG5cbi8qKiBAZGVwcmVjYXRlZCBVc2UgYHdlYmFwaVJlbGVhc2VFbnRyeShuYW1lKWAuIERlZmF1bHQgc3RhcnQgZW50cnkgZm9yIHRoZSBmaXJzdCBBUEkuICovXG5leHBvcnQgY29uc3QgV0VCQVBJX1JFTEVBU0VfRU5UUlkgPSB3ZWJhcGlSZWxlYXNlRW50cnkoREVGQVVMVF9XRUJBUElfTkFNRSk7XG4iXSwibmFtZXMiOlsiREVGQVVMVF9XRUJBUElfTkFNRSIsIldFQkFQSV9QUk9KRUNUX0RJUiIsIldFQkFQSV9SRUxFQVNFX0VOVFJZIiwid2ViYXBpUGFja2FnZU5hbWUiLCJ3ZWJhcGlQb3J0Iiwid2ViYXBpUHJvamVjdERpciIsIndlYmFwaVJlbGVhc2VFbnRyeSIsIm5hbWUiLCJ3b3Jrc3BhY2VOYW1lIiwiYXBpTmFtZSIsImluZGV4Il0sIm1hcHBpbmdzIjoiQUFBQSx1REFBdUQ7Ozs7Ozs7Ozs7O1FBQzFDQTtlQUFBQTs7UUEwQkFDO2VBQUFBOztRQUdBQztlQUFBQTs7UUFiR0M7ZUFBQUE7O1FBS0FDO2VBQUFBOztRQWxCQUM7ZUFBQUE7O1FBUUFDO2VBQUFBOzs7QUFYVCxNQUFNTixzQkFBc0I7QUFHNUIsU0FBU0ssaUJBQWlCRSxJQUFZO0lBQzVDLE9BQU8sQ0FBQyxTQUFTLEVBQUVBLE1BQU07QUFDMUI7QUFNTyxTQUFTRCxtQkFBbUJDLElBQVk7SUFDOUMsT0FBTyxDQUFDLGFBQWEsRUFBRUYsaUJBQWlCRSxNQUFNLGdCQUFnQixDQUFDO0FBQ2hFO0FBR08sU0FBU0osa0JBQWtCSyxhQUFxQixFQUFFQyxPQUFlO0lBQ3ZFLE9BQU8sQ0FBQyxDQUFDLEVBQUVELGNBQWMsQ0FBQyxFQUFFQyxTQUFTO0FBQ3RDO0FBR08sU0FBU0wsV0FBV00sS0FBYTtJQUN2QyxPQUFPLE9BQU9BO0FBQ2Y7QUFHTyxNQUFNVCxxQkFBcUJJLGlCQUFpQkw7QUFHNUMsTUFBTUUsdUJBQXVCSSxtQkFBbUJOIn0=

package/commonjs/src/webapi/create-api.js

@@ -0,0 +1,237 @@
+"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 WEBAPI_PROJECT_DIR () {
+        return _const1.WEBAPI_PROJECT_DIR;
+    },
+    get WEBAPI_RELEASE_ENTRY () {
+        return _const1.WEBAPI_RELEASE_ENTRY;
+    },
+    get scaffoldApi () {
+        return scaffoldApi;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodepath = require("node:path");
+const _composemodel = require("../models/compose.model.js");
+const _configyamlmodel = require("../models/config-yaml.model.js");
+const _const = require("../models/const.js");
+const _devcontainermodel = require("../models/dev-container.model.js");
+const _dockerimagemodel = require("../models/docker-image.model.js");
+const _envfilemodel = require("../models/env-file.model.js");
+const _gitignoremodel = require("../models/gitignore.model.js");
+const _launchjsonmodel = require("../models/launch-json.model.js");
+const _packagejsonmodel = require("../models/package-json.model.js");
+const _projectmodel = require("../models/project.model.js");
+const _tsconfigmodel = require("../models/tsconfig.model.js");
+const _vitestconfigmodel = require("../models/vitest-config.model.js");
+const _vscodesettingsmodel = require("../models/vscode-settings.model.js");
+const _scaffoldservice = require("../services/scaffold.service.js");
+const _apiname = require("./api-name.js");
+const _const1 = require("./const.js");
+const _hostscripts = require("./devcontainer/host-scripts.js");
+const _authfeature = require("./features/auth.feature.js");
+const _databasefeature = require("./features/database.feature.js");
+const _finalizefeature = require("./features/finalize.feature.js");
+const _postmanfeature = require("./features/postman.feature.js");
+const _apipackagejsonmodel = require("./models/api-package-json.model.js");
+const _controllersourcefilemodel = require("./models/controller-source-file.model.js");
+const _githubcimodel = require("./models/github-ci.model.js");
+const _mainsourcefilemodel = require("./models/main-source-file.model.js");
+const _productiondockerfilemodel = require("./models/production-dockerfile.model.js");
+const _samplefilesmodel = require("./models/sample-files.model.js");
+const _webapiimagemodel = require("./models/webapi-image.model.js");
+const features = [
+    _databasefeature.DatabaseFeature,
+    _authfeature.AuthFeature,
+    _postmanfeature.PostmanFeature,
+    _finalizefeature.FinalizeFeature
+];
+async function scaffoldApi(cliOptions) {
+    const targetDir = (0, _nodepath.resolve)(cliOptions.d ?? ".");
+    const projectName = cliOptions.projectName?.trim() || process.env.DECOHERE_PROJECT_NAME?.trim() || (0, _nodepath.basename)(targetDir);
+    const names = (0, _apiname.parseApiNames)(cliOptions.names);
+    const workspace = cliOptions.add ? createAddWorkspace(targetDir, projectName, names) : createWorkspace(targetDir, projectName, names);
+    await _scaffoldservice.ScaffoldService.scaffold(workspace, {
+        ...cliOptions,
+        names
+    }, features);
+}
+function createWorkspace(targetDir, projectName, apiNames) {
+    const monoRepo = new _projectmodel.MonoRepoScaffold();
+    monoRepo.targetDir = targetDir;
+    monoRepo.setName(projectName);
+    const name = monoRepo.name;
+    const compose = new _composemodel.DockerCompose().setProjectName(name).addHeaderComment("Merge .cursor/mcp.json in the service command. postStartCommand runs after Cursor's first MCP snapshot.").addNetwork(name, {
+        name: `samples-${name}`
+    }).addService("devcontainer", {
+        build: ".",
+        volumes: [
+            // Workspace-local (created by initialize.sh as the host user).
+            // Do NOT bind ${HOME}/.npm/... — Docker creates missing host paths as root.
+            "./npm-auth:/home/node/.npm-config",
+            "./gh-auth:/home/node/.config/gh",
+            "webapi-node-modules:/workspace/node_modules",
+            // Named volume (not a Cursor-only mount) so CLI recreates keep Up-arrow history.
+            `${_dockerimagemodel.commandHistory.volumeName}:${_dockerimagemodel.commandHistory.dir}`
+        ],
+        env_file: [
+            "./gh.env"
+        ],
+        environment: {
+            NPM_CONFIG_USERCONFIG: "/home/node/.npm-config/.npmrc"
+        },
+        command: "'bash -c \"CODEBASE_RAG_WORKSPACE=/workspace node --experimental-strip-types /workspace/.devcontainer/codebase-rag-mcp.ts merge || true && exec sleep infinity\"'",
+        networks: [
+            name
+        ]
+    }).addVolume("webapi-node-modules").addVolume(_dockerimagemodel.commandHistory.volumeName);
+    const installCmd = "bash .devcontainer/post-create.sh";
+    const devContainer = new _devcontainermodel.DevContainer().addExtension("biomejs.biome", "vitest.explorer").setInitializeCommand("bash .devcontainer/initialize.sh").setPostCreateCommand(installCmd).setUpdateContentCommand(installCmd).setPostStartCommand("bash .devcontainer/post-start.sh").useCompose();
+    for (const [index, apiName] of apiNames.entries()){
+        const port = (0, _const1.webapiPort)(index);
+        devContainer.forwardPort(port);
+        devContainer.setPortAttributes(port, {
+            label: apiName === _const1.DEFAULT_WEBAPI_NAME ? "API" : apiName,
+            requireLocalPort: true
+        });
+    }
+    // Workspace-level models (repo root)
+    monoRepo.addModel(compose);
+    monoRepo.addModel(devContainer);
+    monoRepo.addModel(new _webapiimagemodel.WebapiDevContainer());
+    monoRepo.addModel(new _productiondockerfilemodel.WebapiProductionDockerfile(apiNames));
+    monoRepo.addModel(new _githubcimodel.GithubCiWorkflows());
+    monoRepo.addModel(new _vscodesettingsmodel.VSCodeSettings(name));
+    monoRepo.addModel(new _launchjsonmodel.LaunchJson(apiNames));
+    monoRepo.addModel(new _tsconfigmodel.TsConfig());
+    monoRepo.addModel(new _vitestconfigmodel.VitestConfig());
+    monoRepo.addModel(new _packagejsonmodel.PackageJson(`${name}.api`, {
+        apiNames,
+        workspaceName: name
+    }));
+    monoRepo.addModel(new _configyamlmodel.ConfigYaml(_const.WELL_KNOWN_FILES.CONFIG_YAML, "config/config.yaml", ""));
+    monoRepo.addModel(new _configyamlmodel.ConfigYaml(_const.WELL_KNOWN_FILES.CONFIG_DEV_YAML, "config/config.dev.yaml", ""));
+    monoRepo.addModel(new _gitignoremodel.Gitignore());
+    monoRepo.addModel(new _envfilemodel.EnvFile());
+    monoRepo.addFile(new _hostscripts.DevContainerHostScripts());
+    // Biome formatter/linter config
+    monoRepo.addFile({
+        files: ()=>[
+                {
+                    filePath: "biome.json",
+                    content: JSON.stringify({
+                        $schema: "https://biomejs.dev/schemas/2.0.0/schema.json",
+                        files: {
+                            includes: [
+                                "**/*.ts",
+                                "**/*.js",
+                                "**/*.json",
+                                "**/*.yml",
+                                "**/*.yaml"
+                            ]
+                        },
+                        assist: {
+                            actions: {
+                                source: {
+                                    organizeImports: "on"
+                                }
+                            }
+                        },
+                        vcs: {
+                            enabled: true,
+                            clientKind: "git",
+                            useIgnoreFile: true
+                        },
+                        formatter: {
+                            enabled: true,
+                            formatWithErrors: true,
+                            indentStyle: "tab",
+                            lineWidth: 95
+                        },
+                        javascript: {
+                            parser: {
+                                unsafeParameterDecoratorsEnabled: true
+                            }
+                        },
+                        linter: {
+                            rules: {
+                                style: {
+                                    useConsistentMemberAccessibility: {
+                                        level: "error",
+                                        options: {
+                                            accessibility: "explicit"
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        overrides: [
+                            {
+                                includes: [
+                                    "**/*.json"
+                                ],
+                                formatter: {
+                                    indentStyle: "space",
+                                    indentWidth: 2
+                                }
+                            }
+                        ]
+                    }, null, 2)
+                }
+            ]
+    });
+    for (const apiName of apiNames){
+        addApiProject(monoRepo, name, apiName);
+    }
+    return monoRepo;
+}
+function createAddWorkspace(targetDir, projectName, apiNames) {
+    if (!(0, _apiname.isDecohereWorkspace)(targetDir)) {
+        throw new _apiname.CreateCliError(`Not a Decohere workspace: ${targetDir}. Scaffold one first with \`npx @decohere/create webapi\`.`);
+    }
+    const existing = (0, _apiname.listExistingApiNames)(targetDir);
+    for (const apiName of apiNames){
+        if (existing.includes(apiName)) {
+            throw new _apiname.CreateCliError(`API "${apiName}" already exists at ${(0, _const1.webapiProjectDir)(apiName)}.`);
+        }
+    }
+    const monoRepo = new _projectmodel.MonoRepoScaffold();
+    monoRepo.targetDir = targetDir;
+    monoRepo.setName(projectName);
+    const name = monoRepo.name;
+    const pkg = _packagejsonmodel.PackageJson.fromFile((0, _nodepath.join)(targetDir, "package.json"));
+    monoRepo.addModel(pkg);
+    monoRepo.addModel((0, _nodefs.existsSync)((0, _nodepath.join)(targetDir, ".env")) ? _envfilemodel.EnvFile.fromFile((0, _nodepath.join)(targetDir, ".env")) : new _envfilemodel.EnvFile());
+    monoRepo.addModel((0, _nodefs.existsSync)((0, _nodepath.join)(targetDir, "config/config.yaml")) ? _configyamlmodel.ConfigYaml.fromFile(_const.WELL_KNOWN_FILES.CONFIG_YAML, "config/config.yaml", (0, _nodepath.join)(targetDir, "config/config.yaml")) : new _configyamlmodel.ConfigYaml(_const.WELL_KNOWN_FILES.CONFIG_YAML, "config/config.yaml", ""));
+    monoRepo.addModel((0, _nodefs.existsSync)((0, _nodepath.join)(targetDir, "config/config.dev.yaml")) ? _configyamlmodel.ConfigYaml.fromFile(_const.WELL_KNOWN_FILES.CONFIG_DEV_YAML, "config/config.dev.yaml", (0, _nodepath.join)(targetDir, "config/config.dev.yaml")) : new _configyamlmodel.ConfigYaml(_const.WELL_KNOWN_FILES.CONFIG_DEV_YAML, "config/config.dev.yaml", ""));
+    for (const [offset, apiName] of apiNames.entries()){
+        const port = (0, _const1.webapiPort)(existing.length + offset);
+        pkg.addScript(`start:${apiName}`, `node ${(0, _const1.webapiReleaseEntry)(apiName)}`);
+        pkg.addScript(`dev:${apiName}`, `PORT=${port} flux serve --project ${(0, _const1.webapiPackageName)(name, apiName)}`);
+        addApiProject(monoRepo, name, apiName);
+    }
+    monoRepo.addModel(new _productiondockerfilemodel.WebapiProductionDockerfile(apiNames, {
+        namedOnly: true
+    }));
+    return monoRepo;
+}
+function addApiProject(monoRepo, workspaceName, apiName) {
+    const apiProject = new _projectmodel.ProjectScaffold((0, _const1.webapiProjectDir)(apiName));
+    apiProject.addModel(new _apipackagejsonmodel.ApiPackageJson(workspaceName, apiName));
+    apiProject.addModel(new _mainsourcefilemodel.MainSourceFile(`${workspaceName}.${apiName}`));
+    apiProject.addModel(new _controllersourcefilemodel.ControllerSourceFile());
+    apiProject.addFile(new _samplefilesmodel.SampleConfigModel());
+    apiProject.addFile(new _samplefilesmodel.SampleServiceModel());
+    monoRepo.addProject(apiProject);
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/create-api.ts"],"sourcesContent":["import { existsSync } from \"node:fs\";\nimport { basename, join, resolve } from \"node:path\";\nimport { DockerCompose } from \"../models/compose.model.js\";\nimport { ConfigYaml } from \"../models/config-yaml.model.js\";\nimport { WELL_KNOWN_FILES } from \"../models/const.js\";\nimport { DevContainer } from \"../models/dev-container.model.js\";\nimport { commandHistory } from \"../models/docker-image.model.js\";\nimport { EnvFile } from \"../models/env-file.model.js\";\nimport { Gitignore } from \"../models/gitignore.model.js\";\nimport { LaunchJson } from \"../models/launch-json.model.js\";\nimport { PackageJson } from \"../models/package-json.model.js\";\nimport { MonoRepoScaffold, ProjectScaffold } from \"../models/project.model.js\";\nimport { TsConfig } from \"../models/tsconfig.model.js\";\nimport { VitestConfig } from \"../models/vitest-config.model.js\";\nimport { VSCodeSettings } from \"../models/vscode-settings.model.js\";\nimport { ScaffoldService } from \"../services/scaffold.service.js\";\nimport {\n\tCreateCliError,\n\tisDecohereWorkspace,\n\tlistExistingApiNames,\n\tparseApiNames,\n} from \"./api-name.js\";\nimport {\n\tDEFAULT_WEBAPI_NAME,\n\twebapiPackageName,\n\twebapiPort,\n\twebapiProjectDir,\n\twebapiReleaseEntry,\n} from \"./const.js\";\nimport { DevContainerHostScripts } from \"./devcontainer/host-scripts.js\";\nimport { AuthFeature } from \"./features/auth.feature.js\";\nimport { DatabaseFeature } from \"./features/database.feature.js\";\nimport { FinalizeFeature } from \"./features/finalize.feature.js\";\nimport { PostmanFeature } from \"./features/postman.feature.js\";\nimport { ApiPackageJson } from \"./models/api-package-json.model.js\";\nimport { ControllerSourceFile } from \"./models/controller-source-file.model.js\";\nimport { GithubCiWorkflows } from \"./models/github-ci.model.js\";\nimport { MainSourceFile } from \"./models/main-source-file.model.js\";\nimport { WebapiProductionDockerfile } from \"./models/production-dockerfile.model.js\";\nimport { SampleConfigModel, SampleServiceModel } from \"./models/sample-files.model.js\";\nimport { WebapiDevContainer } from \"./models/webapi-image.model.js\";\n\nexport { WEBAPI_PROJECT_DIR, WEBAPI_RELEASE_ENTRY } from \"./const.js\";\n\nexport type ApiOptions = {\n\td?: string;\n\t/** Host project name (directory basename). Required when scaffolding into `/workspace`. */\n\tprojectName?: string;\n\t/** API slugs under `projects/`. Default `[\"api\"]`. Repeatable `--name`. */\n\tnames?: string[];\n\t/** Add APIs to an existing Decohere workspace instead of creating a new one. */\n\tadd?: boolean;\n\tauthProvider?: \"auth0\" | \"none\";\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n\tpostmanProvider?: \"api\" | \"local\" | \"none\";\n\tinstallDependencies?: \"yes\" | \"no\";\n};\n\nconst features = [DatabaseFeature, AuthFeature, PostmanFeature, FinalizeFeature];\n\nexport async function scaffoldApi(cliOptions: ApiOptions) {\n\tconst targetDir = resolve(cliOptions.d ?? \".\");\n\tconst projectName =\n\t\tcliOptions.projectName?.trim() ||\n\t\tprocess.env.DECOHERE_PROJECT_NAME?.trim() ||\n\t\tbasename(targetDir);\n\tconst names = parseApiNames(cliOptions.names);\n\tconst workspace = cliOptions.add\n\t\t? createAddWorkspace(targetDir, projectName, names)\n\t\t: createWorkspace(targetDir, projectName, names);\n\tawait ScaffoldService.scaffold(workspace, { ...cliOptions, names }, features);\n}\n\nfunction createWorkspace(\n\ttargetDir: string,\n\tprojectName: string,\n\tapiNames: readonly string[],\n): MonoRepoScaffold {\n\tconst monoRepo = new MonoRepoScaffold();\n\tmonoRepo.targetDir = targetDir;\n\tmonoRepo.setName(projectName);\n\tconst name = monoRepo.name;\n\n\tconst compose = new DockerCompose()\n\t\t.setProjectName(name)\n\t\t.addHeaderComment(\n\t\t\t\"Merge .cursor/mcp.json in the service command. postStartCommand runs after Cursor's first MCP snapshot.\",\n\t\t)\n\t\t.addNetwork(name, { name: `samples-${name}` })\n\t\t.addService(\"devcontainer\", {\n\t\t\tbuild: \".\",\n\t\t\tvolumes: [\n\t\t\t\t// Workspace-local (created by initialize.sh as the host user).\n\t\t\t\t// Do NOT bind ${HOME}/.npm/... — Docker creates missing host paths as root.\n\t\t\t\t\"./npm-auth:/home/node/.npm-config\",\n\t\t\t\t\"./gh-auth:/home/node/.config/gh\",\n\t\t\t\t\"webapi-node-modules:/workspace/node_modules\",\n\t\t\t\t// Named volume (not a Cursor-only mount) so CLI recreates keep Up-arrow history.\n\t\t\t\t`${commandHistory.volumeName}:${commandHistory.dir}`,\n\t\t\t],\n\t\t\tenv_file: [\"./gh.env\"],\n\t\t\tenvironment: { NPM_CONFIG_USERCONFIG: \"/home/node/.npm-config/.npmrc\" },\n\t\t\tcommand:\n\t\t\t\t\"'bash -c \\\"CODEBASE_RAG_WORKSPACE=/workspace node --experimental-strip-types /workspace/.devcontainer/codebase-rag-mcp.ts merge || true && exec sleep infinity\\\"'\",\n\t\t\tnetworks: [name],\n\t\t})\n\t\t.addVolume(\"webapi-node-modules\")\n\t\t.addVolume(commandHistory.volumeName);\n\n\tconst installCmd = \"bash .devcontainer/post-create.sh\";\n\tconst devContainer = new DevContainer()\n\t\t.addExtension(\"biomejs.biome\", \"vitest.explorer\")\n\t\t.setInitializeCommand(\"bash .devcontainer/initialize.sh\")\n\t\t.setPostCreateCommand(installCmd)\n\t\t.setUpdateContentCommand(installCmd)\n\t\t.setPostStartCommand(\"bash .devcontainer/post-start.sh\")\n\t\t.useCompose();\n\n\tfor (const [index, apiName] of apiNames.entries()) {\n\t\tconst port = webapiPort(index);\n\t\tdevContainer.forwardPort(port);\n\t\tdevContainer.setPortAttributes(port, {\n\t\t\tlabel: apiName === DEFAULT_WEBAPI_NAME ? \"API\" : apiName,\n\t\t\trequireLocalPort: true,\n\t\t});\n\t}\n\n\t// Workspace-level models (repo root)\n\tmonoRepo.addModel(compose);\n\tmonoRepo.addModel(devContainer);\n\tmonoRepo.addModel(new WebapiDevContainer());\n\tmonoRepo.addModel(new WebapiProductionDockerfile(apiNames));\n\tmonoRepo.addModel(new GithubCiWorkflows());\n\tmonoRepo.addModel(new VSCodeSettings(name));\n\tmonoRepo.addModel(new LaunchJson(apiNames));\n\tmonoRepo.addModel(new TsConfig());\n\tmonoRepo.addModel(new VitestConfig());\n\tmonoRepo.addModel(new PackageJson(`${name}.api`, { apiNames, workspaceName: name }));\n\tmonoRepo.addModel(new ConfigYaml(WELL_KNOWN_FILES.CONFIG_YAML, \"config/config.yaml\", \"\"));\n\tmonoRepo.addModel(\n\t\tnew ConfigYaml(WELL_KNOWN_FILES.CONFIG_DEV_YAML, \"config/config.dev.yaml\", \"\"),\n\t);\n\tmonoRepo.addModel(new Gitignore());\n\tmonoRepo.addModel(new EnvFile());\n\tmonoRepo.addFile(new DevContainerHostScripts());\n\n\t// Biome formatter/linter config\n\tmonoRepo.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: \"biome.json\",\n\t\t\t\tcontent: JSON.stringify(\n\t\t\t\t\t{\n\t\t\t\t\t\t$schema: \"https://biomejs.dev/schemas/2.0.0/schema.json\",\n\t\t\t\t\t\tfiles: {\n\t\t\t\t\t\t\tincludes: [\"**/*.ts\", \"**/*.js\", \"**/*.json\", \"**/*.yml\", \"**/*.yaml\"],\n\t\t\t\t\t\t},\n\t\t\t\t\t\tassist: { actions: { source: { organizeImports: \"on\" } } },\n\t\t\t\t\t\tvcs: { enabled: true, clientKind: \"git\", useIgnoreFile: true },\n\t\t\t\t\t\tformatter: {\n\t\t\t\t\t\t\tenabled: true,\n\t\t\t\t\t\t\tformatWithErrors: true,\n\t\t\t\t\t\t\tindentStyle: \"tab\",\n\t\t\t\t\t\t\tlineWidth: 95,\n\t\t\t\t\t\t},\n\t\t\t\t\t\tjavascript: { parser: { unsafeParameterDecoratorsEnabled: true } },\n\t\t\t\t\t\tlinter: {\n\t\t\t\t\t\t\trules: {\n\t\t\t\t\t\t\t\tstyle: {\n\t\t\t\t\t\t\t\t\tuseConsistentMemberAccessibility: {\n\t\t\t\t\t\t\t\t\t\tlevel: \"error\",\n\t\t\t\t\t\t\t\t\t\toptions: { accessibility: \"explicit\" },\n\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t\toverrides: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tincludes: [\"**/*.json\"],\n\t\t\t\t\t\t\t\tformatter: { indentStyle: \"space\", indentWidth: 2 },\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t\tnull,\n\t\t\t\t\t2,\n\t\t\t\t),\n\t\t\t},\n\t\t],\n\t});\n\n\tfor (const apiName of apiNames) {\n\t\taddApiProject(monoRepo, name, apiName);\n\t}\n\n\treturn monoRepo;\n}\n\nfunction createAddWorkspace(\n\ttargetDir: string,\n\tprojectName: string,\n\tapiNames: readonly string[],\n): MonoRepoScaffold {\n\tif (!isDecohereWorkspace(targetDir)) {\n\t\tthrow new CreateCliError(\n\t\t\t`Not a Decohere workspace: ${targetDir}. Scaffold one first with \\`npx @decohere/create webapi\\`.`,\n\t\t);\n\t}\n\n\tconst existing = listExistingApiNames(targetDir);\n\tfor (const apiName of apiNames) {\n\t\tif (existing.includes(apiName)) {\n\t\t\tthrow new CreateCliError(\n\t\t\t\t`API \"${apiName}\" already exists at ${webapiProjectDir(apiName)}.`,\n\t\t\t);\n\t\t}\n\t}\n\n\tconst monoRepo = new MonoRepoScaffold();\n\tmonoRepo.targetDir = targetDir;\n\tmonoRepo.setName(projectName);\n\tconst name = monoRepo.name;\n\n\tconst pkg = PackageJson.fromFile(join(targetDir, \"package.json\"));\n\tmonoRepo.addModel(pkg);\n\tmonoRepo.addModel(\n\t\texistsSync(join(targetDir, \".env\"))\n\t\t\t? EnvFile.fromFile(join(targetDir, \".env\"))\n\t\t\t: new EnvFile(),\n\t);\n\tmonoRepo.addModel(\n\t\texistsSync(join(targetDir, \"config/config.yaml\"))\n\t\t\t? ConfigYaml.fromFile(\n\t\t\t\t\tWELL_KNOWN_FILES.CONFIG_YAML,\n\t\t\t\t\t\"config/config.yaml\",\n\t\t\t\t\tjoin(targetDir, \"config/config.yaml\"),\n\t\t\t\t)\n\t\t\t: new ConfigYaml(WELL_KNOWN_FILES.CONFIG_YAML, \"config/config.yaml\", \"\"),\n\t);\n\tmonoRepo.addModel(\n\t\texistsSync(join(targetDir, \"config/config.dev.yaml\"))\n\t\t\t? ConfigYaml.fromFile(\n\t\t\t\t\tWELL_KNOWN_FILES.CONFIG_DEV_YAML,\n\t\t\t\t\t\"config/config.dev.yaml\",\n\t\t\t\t\tjoin(targetDir, \"config/config.dev.yaml\"),\n\t\t\t\t)\n\t\t\t: new ConfigYaml(WELL_KNOWN_FILES.CONFIG_DEV_YAML, \"config/config.dev.yaml\", \"\"),\n\t);\n\n\tfor (const [offset, apiName] of apiNames.entries()) {\n\t\tconst port = webapiPort(existing.length + offset);\n\t\tpkg.addScript(`start:${apiName}`, `node ${webapiReleaseEntry(apiName)}`);\n\t\tpkg.addScript(\n\t\t\t`dev:${apiName}`,\n\t\t\t`PORT=${port} flux serve --project ${webapiPackageName(name, apiName)}`,\n\t\t);\n\t\taddApiProject(monoRepo, name, apiName);\n\t}\n\tmonoRepo.addModel(new WebapiProductionDockerfile(apiNames, { namedOnly: true }));\n\n\treturn monoRepo;\n}\n\nfunction addApiProject(\n\tmonoRepo: MonoRepoScaffold,\n\tworkspaceName: string,\n\tapiName: string,\n): void {\n\tconst apiProject = new ProjectScaffold(webapiProjectDir(apiName));\n\tapiProject.addModel(new ApiPackageJson(workspaceName, apiName));\n\tapiProject.addModel(new MainSourceFile(`${workspaceName}.${apiName}`));\n\tapiProject.addModel(new ControllerSourceFile());\n\tapiProject.addFile(new SampleConfigModel());\n\tapiProject.addFile(new SampleServiceModel());\n\tmonoRepo.addProject(apiProject);\n}\n"],"names":["WEBAPI_PROJECT_DIR","WEBAPI_RELEASE_ENTRY","scaffoldApi","features","DatabaseFeature","AuthFeature","PostmanFeature","FinalizeFeature","cliOptions","targetDir","resolve","d","projectName","trim","process","env","DECOHERE_PROJECT_NAME","basename","names","parseApiNames","workspace","add","createAddWorkspace","createWorkspace","ScaffoldService","scaffold","apiNames","monoRepo","MonoRepoScaffold","setName","name","compose","DockerCompose","setProjectName","addHeaderComment","addNetwork","addService","build","volumes","commandHistory","volumeName","dir","env_file","environment","NPM_CONFIG_USERCONFIG","command","networks","addVolume","installCmd","devContainer","DevContainer","addExtension","setInitializeCommand","setPostCreateCommand","setUpdateContentCommand","setPostStartCommand","useCompose","index","apiName","entries","port","webapiPort","forwardPort","setPortAttributes","label","DEFAULT_WEBAPI_NAME","requireLocalPort","addModel","WebapiDevContainer","WebapiProductionDockerfile","GithubCiWorkflows","VSCodeSettings","LaunchJson","TsConfig","VitestConfig","PackageJson","workspaceName","ConfigYaml","WELL_KNOWN_FILES","CONFIG_YAML","CONFIG_DEV_YAML","Gitignore","EnvFile","addFile","DevContainerHostScripts","files","filePath","content","JSON","stringify","$schema","includes","assist","actions","source","organizeImports","vcs","enabled","clientKind","useIgnoreFile","formatter","formatWithErrors","indentStyle","lineWidth","javascript","parser","unsafeParameterDecoratorsEnabled","linter","rules","style","useConsistentMemberAccessibility","level","options","accessibility","overrides","indentWidth","addApiProject","isDecohereWorkspace","CreateCliError","existing","listExistingApiNames","webapiProjectDir","pkg","fromFile","join","existsSync","offset","length","addScript","webapiReleaseEntry","webapiPackageName","namedOnly","apiProject","ProjectScaffold","ApiPackageJson","MainSourceFile","ControllerSourceFile","SampleConfigModel","SampleServiceModel","addProject"],"mappings":"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"}