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

package/es6/src/webapi/workspace-readme.js

@@ -0,0 +1,89 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { WELL_KNOWN_FILES } from "../models/const.js";
+import { apiNameFromProjectDir, listExistingApiNames } from "./api-name.js";
+/** Pure renderer — keep feature sections short and copy-paste ready. */ export function renderWorkspaceReadme(input) {
+    const { projectName, apiNames, hasPostgres, hasAuth0, hasPostman } = input;
+    const apis = apiNames.length > 0 ? apiNames : [
+        "api"
+    ];
+    const lines = [
+        `# ${projectName}`,
+        "",
+        "Decohere web API workspace. Scaffolded with [`@decohere/create`](https://www.npmjs.com/package/@decohere/create).",
+        "",
+        "## Get started",
+        "",
+        "1. Open this folder in VS Code / Cursor.",
+        "2. **Reopen in Container** (or rebuild the Dev Container).",
+        "   Host `initialize.sh` and container `post-start.sh` ask y/N (TTY only) before npm auth or codebase RAG MCP.",
+        "   Skip or decline; missing TTY skips. RAG credentials land in `.cursor/` (gitignored).",
+        "3. Install dependencies if needed:",
+        "",
+        "```bash",
+        "pnpm install",
+        "```",
+        "",
+        "## Develop",
+        "",
+        "```bash",
+        "pnpm dev              # Flux HMR (first API)",
+        "pnpm start            # run the compiled first API",
+        "pnpm run build        # forge release build"
+    ];
+    for (const name of apis){
+        lines.push(`pnpm run dev:${name}     # HMR for ${name}`);
+        lines.push(`pnpm run start:${name}   # production entry for ${name}`);
+    }
+    lines.push("```", "");
+    lines.push("## Logging", "", "In development, Scribe uses pino-pretty and rolling files under `logs/` (gitignored).", "When `NODE_ENV=production`, the process writes structured JSON to stdout and does not rotate files.", "Ship and retain those streams outside the app (platform logs, a sidecar, or a log agent) so shipping can change without rebuilding.", "", "Override roll path and rotation without changing app code:", "`SCRIBE_LOG_FILE`, `SCRIBE_LOG_SIZE`, `SCRIBE_LOG_FREQUENCY`, `SCRIBE_LOG_KEEP`.", "", 'Opt into in-process pretty or roll in production only with `{ when: "always" }` on `scribe.withPinoPretty` / `scribe.withPinoRoll`.', "");
+    if (hasPostgres) {
+        lines.push("## Database", "", "Postgres runs via Dev Container Compose:", "", "```bash", "pnpm db:up", "pnpm db:down", "pnpm db:reset", "```", "");
+    }
+    lines.push("## Deploy", "", "PaaS hosts (`docker build` from the repo root) use the scaffolded `Dockerfile`.", "The runtime image installs production dependencies only (`pnpm install --prod`);", "Forge, TypeScript, Biome, and Vitest stay in the build stage.", "", "```bash", `docker build -t ${projectName} .`, "```", "", "Extra APIs: `docker build -f Dockerfile.<name> .`", "");
+    lines.push("## Add another API", "", "```bash", "decohere add api <name>", "```", "", "Example: `decohere add api billing`", "");
+    if (hasAuth0) {
+        lines.push("## Auth0", "", "JWT auth is wired from `.env` (`AUTH0_ISSUER_BASE_URL`, `AUTH0_AUDIENCE`).", "Set those values (or re-run scaffold with `--auth auth0`) before calling protected routes.", "");
+    }
+    if (hasPostman) {
+        lines.push("## Postman", "", "Open this **project root** in Postman Local View (Files → Open folder), not the `postman/` subfolder.", "Select the Local environment, then Authorization → Get New Access Token when Auth0 is enabled.", "");
+    }
+    lines.push("## More", "", "- Package docs: https://www.npmjs.com/package/@decohere/create", "- After `decohere add api`, this README is refreshed so scripts and APIs stay accurate.", "");
+    return `${lines.join("\n")}`;
+}
+export function resolveWorkspaceReadmeInput(workspace, options) {
+    const newNames = workspace.getProjects().map((project)=>apiNameFromProjectDir(project.dir));
+    const apiNames = options.add ? mergeApiNames(listExistingApiNames(workspace.targetDir), newNames) : newNames;
+    const pkg = workspace.getModel(WELL_KNOWN_FILES.PACKAGE_JSON);
+    const env = workspace.getModel(WELL_KNOWN_FILES.ENV_FILE);
+    const hasPostgres = options.databaseProvider === "postgres/typeorm" || Boolean(pkg?.hasScript("db:up"));
+    const hasAuth0 = options.authProvider === "auth0" || Boolean(env?.hasEntry("AUTH0_ISSUER_BASE_URL"));
+    const hasPostman = options.postmanProvider === "local" || options.postmanProvider === "api" || existsSync(join(workspace.targetDir, "postman")) || existsSync(join(workspace.targetDir, ".postman"));
+    return {
+        projectName: workspace.name,
+        apiNames,
+        hasPostgres,
+        hasAuth0,
+        hasPostman
+    };
+}
+export function writeWorkspaceReadme(workspace, options) {
+    const content = renderWorkspaceReadme(resolveWorkspaceReadmeInput(workspace, options));
+    workspace.addFile({
+        files: ()=>[
+                {
+                    filePath: "README.md",
+                    content
+                }
+            ]
+    });
+}
+function mergeApiNames(existing, added) {
+    const seen = new Set(existing);
+    return [
+        ...existing,
+        ...added.filter((name)=>!seen.has(name))
+    ];
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/workspace-readme.ts"],"sourcesContent":["import { existsSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { WELL_KNOWN_FILES } from \"../models/const.js\";\nimport type { EnvFile } from \"../models/env-file.model.js\";\nimport type { PackageJson } from \"../models/package-json.model.js\";\nimport type { WorkspaceScaffold } from \"../models/project.model.js\";\nimport { apiNameFromProjectDir, listExistingApiNames } from \"./api-name.js\";\n\nexport type WorkspaceReadmeOptions = {\n\tadd?: boolean;\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n\tauthProvider?: \"auth0\" | \"none\";\n\tpostmanProvider?: \"api\" | \"local\" | \"none\";\n};\n\nexport type WorkspaceReadmeInput = {\n\tprojectName: string;\n\tapiNames: readonly string[];\n\thasPostgres: boolean;\n\thasAuth0: boolean;\n\thasPostman: boolean;\n};\n\n/** Pure renderer — keep feature sections short and copy-paste ready. */\nexport function renderWorkspaceReadme(input: WorkspaceReadmeInput): string {\n\tconst { projectName, apiNames, hasPostgres, hasAuth0, hasPostman } = input;\n\tconst apis = apiNames.length > 0 ? apiNames : [\"api\"];\n\tconst lines: string[] = [\n\t\t`# ${projectName}`,\n\t\t\"\",\n\t\t\"Decohere web API workspace. Scaffolded with [`@decohere/create`](https://www.npmjs.com/package/@decohere/create).\",\n\t\t\"\",\n\t\t\"## Get started\",\n\t\t\"\",\n\t\t\"1. Open this folder in VS Code / Cursor.\",\n\t\t\"2. **Reopen in Container** (or rebuild the Dev Container).\",\n\t\t\"   Host `initialize.sh` and container `post-start.sh` ask y/N (TTY only) before npm auth or codebase RAG MCP.\",\n\t\t\"   Skip or decline; missing TTY skips. RAG credentials land in `.cursor/` (gitignored).\",\n\t\t\"3. Install dependencies if needed:\",\n\t\t\"\",\n\t\t\"```bash\",\n\t\t\"pnpm install\",\n\t\t\"```\",\n\t\t\"\",\n\t\t\"## Develop\",\n\t\t\"\",\n\t\t\"```bash\",\n\t\t\"pnpm dev              # Flux HMR (first API)\",\n\t\t\"pnpm start            # run the compiled first API\",\n\t\t\"pnpm run build        # forge release build\",\n\t];\n\n\tfor (const name of apis) {\n\t\tlines.push(`pnpm run dev:${name}     # HMR for ${name}`);\n\t\tlines.push(`pnpm run start:${name}   # production entry for ${name}`);\n\t}\n\n\tlines.push(\"```\", \"\");\n\n\tlines.push(\n\t\t\"## Logging\",\n\t\t\"\",\n\t\t\"In development, Scribe uses pino-pretty and rolling files under `logs/` (gitignored).\",\n\t\t\"When `NODE_ENV=production`, the process writes structured JSON to stdout and does not rotate files.\",\n\t\t\"Ship and retain those streams outside the app (platform logs, a sidecar, or a log agent) so shipping can change without rebuilding.\",\n\t\t\"\",\n\t\t\"Override roll path and rotation without changing app code:\",\n\t\t\"`SCRIBE_LOG_FILE`, `SCRIBE_LOG_SIZE`, `SCRIBE_LOG_FREQUENCY`, `SCRIBE_LOG_KEEP`.\",\n\t\t\"\",\n\t\t'Opt into in-process pretty or roll in production only with `{ when: \"always\" }` on `scribe.withPinoPretty` / `scribe.withPinoRoll`.',\n\t\t\"\",\n\t);\n\n\tif (hasPostgres) {\n\t\tlines.push(\n\t\t\t\"## Database\",\n\t\t\t\"\",\n\t\t\t\"Postgres runs via Dev Container Compose:\",\n\t\t\t\"\",\n\t\t\t\"```bash\",\n\t\t\t\"pnpm db:up\",\n\t\t\t\"pnpm db:down\",\n\t\t\t\"pnpm db:reset\",\n\t\t\t\"```\",\n\t\t\t\"\",\n\t\t);\n\t}\n\n\tlines.push(\n\t\t\"## Deploy\",\n\t\t\"\",\n\t\t\"PaaS hosts (`docker build` from the repo root) use the scaffolded `Dockerfile`.\",\n\t\t\"The runtime image installs production dependencies only (`pnpm install --prod`);\",\n\t\t\"Forge, TypeScript, Biome, and Vitest stay in the build stage.\",\n\t\t\"\",\n\t\t\"```bash\",\n\t\t`docker build -t ${projectName} .`,\n\t\t\"```\",\n\t\t\"\",\n\t\t\"Extra APIs: `docker build -f Dockerfile.<name> .`\",\n\t\t\"\",\n\t);\n\n\tlines.push(\n\t\t\"## Add another API\",\n\t\t\"\",\n\t\t\"```bash\",\n\t\t\"decohere add api <name>\",\n\t\t\"```\",\n\t\t\"\",\n\t\t\"Example: `decohere add api billing`\",\n\t\t\"\",\n\t);\n\n\tif (hasAuth0) {\n\t\tlines.push(\n\t\t\t\"## Auth0\",\n\t\t\t\"\",\n\t\t\t\"JWT auth is wired from `.env` (`AUTH0_ISSUER_BASE_URL`, `AUTH0_AUDIENCE`).\",\n\t\t\t\"Set those values (or re-run scaffold with `--auth auth0`) before calling protected routes.\",\n\t\t\t\"\",\n\t\t);\n\t}\n\n\tif (hasPostman) {\n\t\tlines.push(\n\t\t\t\"## Postman\",\n\t\t\t\"\",\n\t\t\t\"Open this **project root** in Postman Local View (Files → Open folder), not the `postman/` subfolder.\",\n\t\t\t\"Select the Local environment, then Authorization → Get New Access Token when Auth0 is enabled.\",\n\t\t\t\"\",\n\t\t);\n\t}\n\n\tlines.push(\n\t\t\"## More\",\n\t\t\"\",\n\t\t\"- Package docs: https://www.npmjs.com/package/@decohere/create\",\n\t\t\"- After `decohere add api`, this README is refreshed so scripts and APIs stay accurate.\",\n\t\t\"\",\n\t);\n\n\treturn `${lines.join(\"\\n\")}`;\n}\n\nexport function resolveWorkspaceReadmeInput(\n\tworkspace: WorkspaceScaffold,\n\toptions: WorkspaceReadmeOptions,\n): WorkspaceReadmeInput {\n\tconst newNames = workspace\n\t\t.getProjects()\n\t\t.map((project) => apiNameFromProjectDir(project.dir));\n\tconst apiNames = options.add\n\t\t? mergeApiNames(listExistingApiNames(workspace.targetDir), newNames)\n\t\t: newNames;\n\n\tconst pkg = workspace.getModel<PackageJson>(WELL_KNOWN_FILES.PACKAGE_JSON);\n\tconst env = workspace.getModel<EnvFile>(WELL_KNOWN_FILES.ENV_FILE);\n\n\tconst hasPostgres =\n\t\toptions.databaseProvider === \"postgres/typeorm\" || Boolean(pkg?.hasScript(\"db:up\"));\n\tconst hasAuth0 =\n\t\toptions.authProvider === \"auth0\" || Boolean(env?.hasEntry(\"AUTH0_ISSUER_BASE_URL\"));\n\tconst hasPostman =\n\t\toptions.postmanProvider === \"local\" ||\n\t\toptions.postmanProvider === \"api\" ||\n\t\texistsSync(join(workspace.targetDir, \"postman\")) ||\n\t\texistsSync(join(workspace.targetDir, \".postman\"));\n\n\treturn {\n\t\tprojectName: workspace.name,\n\t\tapiNames,\n\t\thasPostgres,\n\t\thasAuth0,\n\t\thasPostman,\n\t};\n}\n\nexport function writeWorkspaceReadme(\n\tworkspace: WorkspaceScaffold,\n\toptions: WorkspaceReadmeOptions,\n): void {\n\tconst content = renderWorkspaceReadme(resolveWorkspaceReadmeInput(workspace, options));\n\tworkspace.addFile({\n\t\tfiles: () => [{ filePath: \"README.md\", content }],\n\t});\n}\n\nfunction mergeApiNames(existing: readonly string[], added: readonly string[]): string[] {\n\tconst seen = new Set(existing);\n\treturn [...existing, ...added.filter((name) => !seen.has(name))];\n}\n"],"names":["existsSync","join","WELL_KNOWN_FILES","apiNameFromProjectDir","listExistingApiNames","renderWorkspaceReadme","input","projectName","apiNames","hasPostgres","hasAuth0","hasPostman","apis","length","lines","name","push","resolveWorkspaceReadmeInput","workspace","options","newNames","getProjects","map","project","dir","add","mergeApiNames","targetDir","pkg","getModel","PACKAGE_JSON","env","ENV_FILE","databaseProvider","Boolean","hasScript","authProvider","hasEntry","postmanProvider","writeWorkspaceReadme","content","addFile","files","filePath","existing","added","seen","Set","filter","has"],"mappings":"AAAA,SAASA,UAAU,QAAQ,UAAU;AACrC,SAASC,IAAI,QAAQ,YAAY;AACjC,SAASC,gBAAgB,QAAQ,qBAAqB;AAItD,SAASC,qBAAqB,EAAEC,oBAAoB,QAAQ,gBAAgB;AAiB5E,sEAAsE,GACtE,OAAO,SAASC,sBAAsBC,KAA2B;IAChE,MAAM,EAAEC,WAAW,EAAEC,QAAQ,EAAEC,WAAW,EAAEC,QAAQ,EAAEC,UAAU,EAAE,GAAGL;IACrE,MAAMM,OAAOJ,SAASK,MAAM,GAAG,IAAIL,WAAW;QAAC;KAAM;IACrD,MAAMM,QAAkB;QACvB,CAAC,EAAE,EAAEP,aAAa;QAClB;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;KACA;IAED,KAAK,MAAMQ,QAAQH,KAAM;QACxBE,MAAME,IAAI,CAAC,CAAC,aAAa,EAAED,KAAK,eAAe,EAAEA,MAAM;QACvDD,MAAME,IAAI,CAAC,CAAC,eAAe,EAAED,KAAK,0BAA0B,EAAEA,MAAM;IACrE;IAEAD,MAAME,IAAI,CAAC,OAAO;IAElBF,MAAME,IAAI,CACT,cACA,IACA,yFACA,uGACA,uIACA,IACA,8DACA,oFACA,IACA,uIACA;IAGD,IAAIP,aAAa;QAChBK,MAAME,IAAI,CACT,eACA,IACA,4CACA,IACA,WACA,cACA,gBACA,iBACA,OACA;IAEF;IAEAF,MAAME,IAAI,CACT,aACA,IACA,mFACA,oFACA,iEACA,IACA,WACA,CAAC,gBAAgB,EAAET,YAAY,EAAE,CAAC,EAClC,OACA,IACA,qDACA;IAGDO,MAAME,IAAI,CACT,sBACA,IACA,WACA,2BACA,OACA,IACA,uCACA;IAGD,IAAIN,UAAU;QACbI,MAAME,IAAI,CACT,YACA,IACA,8EACA,8FACA;IAEF;IAEA,IAAIL,YAAY;QACfG,MAAME,IAAI,CACT,cACA,IACA,yGACA,kGACA;IAEF;IAEAF,MAAME,IAAI,CACT,WACA,IACA,kEACA,2FACA;IAGD,OAAO,GAAGF,MAAMb,IAAI,CAAC,OAAO;AAC7B;AAEA,OAAO,SAASgB,4BACfC,SAA4B,EAC5BC,OAA+B;IAE/B,MAAMC,WAAWF,UACfG,WAAW,GACXC,GAAG,CAAC,CAACC,UAAYpB,sBAAsBoB,QAAQC,GAAG;IACpD,MAAMhB,WAAWW,QAAQM,GAAG,GACzBC,cAActB,qBAAqBc,UAAUS,SAAS,GAAGP,YACzDA;IAEH,MAAMQ,MAAMV,UAAUW,QAAQ,CAAc3B,iBAAiB4B,YAAY;IACzE,MAAMC,MAAMb,UAAUW,QAAQ,CAAU3B,iBAAiB8B,QAAQ;IAEjE,MAAMvB,cACLU,QAAQc,gBAAgB,KAAK,sBAAsBC,QAAQN,KAAKO,UAAU;IAC3E,MAAMzB,WACLS,QAAQiB,YAAY,KAAK,WAAWF,QAAQH,KAAKM,SAAS;IAC3D,MAAM1B,aACLQ,QAAQmB,eAAe,KAAK,WAC5BnB,QAAQmB,eAAe,KAAK,SAC5BtC,WAAWC,KAAKiB,UAAUS,SAAS,EAAE,eACrC3B,WAAWC,KAAKiB,UAAUS,SAAS,EAAE;IAEtC,OAAO;QACNpB,aAAaW,UAAUH,IAAI;QAC3BP;QACAC;QACAC;QACAC;IACD;AACD;AAEA,OAAO,SAAS4B,qBACfrB,SAA4B,EAC5BC,OAA+B;IAE/B,MAAMqB,UAAUnC,sBAAsBY,4BAA4BC,WAAWC;IAC7ED,UAAUuB,OAAO,CAAC;QACjBC,OAAO,IAAM;gBAAC;oBAAEC,UAAU;oBAAaH;gBAAQ;aAAE;IAClD;AACD;AAEA,SAASd,cAAckB,QAA2B,EAAEC,KAAwB;IAC3E,MAAMC,OAAO,IAAIC,IAAIH;IACrB,OAAO;WAAIA;WAAaC,MAAMG,MAAM,CAAC,CAACjC,OAAS,CAAC+B,KAAKG,GAAG,CAAClC;KAAO;AACjE"}

package/es6/src/webapi.action.js

@@ -0,0 +1,20 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { injectable } from "@decohere/crucible/decorators";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { runScaffoldApi, toApiOptions } from "./webapi/cli-options.js";
+export class WebapiAction {
+    async run(options) {
+        await runScaffoldApi(toApiOptions(options.directory, options));
+        return ActionResponse.Success("webapi");
+    }
+}
+WebapiAction = _ts_decorate([
+    injectable()
+], WebapiAction);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy93ZWJhcGkuYWN0aW9uLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGluamVjdGFibGUgfSBmcm9tIFwiQGRlY29oZXJlL2NydWNpYmxlL2RlY29yYXRvcnNcIjtcbmltcG9ydCB7IHR5cGUgQWN0aW9uLCBBY3Rpb25SZXNwb25zZSB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvY2xpXCI7XG5pbXBvcnQgeyBydW5TY2FmZm9sZEFwaSwgdG9BcGlPcHRpb25zIH0gZnJvbSBcIi4vd2ViYXBpL2NsaS1vcHRpb25zLmpzXCI7XG5cbmV4cG9ydCB0eXBlIFdlYmFwaU9wdGlvbnMgPSB7XG5cdGRpcmVjdG9yeT86IHN0cmluZztcblx0ZD86IHN0cmluZztcblx0bmFtZT86IHN0cmluZyB8IHN0cmluZ1tdO1xuXHRkYXRhYmFzZT86IHN0cmluZztcblx0YXV0aD86IHN0cmluZztcblx0cG9zdG1hbj86IHN0cmluZztcblx0eWVzPzogYm9vbGVhbjtcblx0aW5zdGFsbD86IHN0cmluZztcbn07XG5cbkBpbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBXZWJhcGlBY3Rpb24gaW1wbGVtZW50cyBBY3Rpb248V2ViYXBpT3B0aW9ucz4ge1xuXHRwdWJsaWMgYXN5bmMgcnVuKG9wdGlvbnM6IFdlYmFwaU9wdGlvbnMpOiBQcm9taXNlPEFjdGlvblJlc3BvbnNlPiB7XG5cdFx0YXdhaXQgcnVuU2NhZmZvbGRBcGkodG9BcGlPcHRpb25zKG9wdGlvbnMuZGlyZWN0b3J5LCBvcHRpb25zKSk7XG5cdFx0cmV0dXJuIEFjdGlvblJlc3BvbnNlLlN1Y2Nlc3MoXCJ3ZWJhcGlcIik7XG5cdH1cbn1cbiJdLCJuYW1lcyI6WyJpbmplY3RhYmxlIiwiQWN0aW9uUmVzcG9uc2UiLCJydW5TY2FmZm9sZEFwaSIsInRvQXBpT3B0aW9ucyIsIldlYmFwaUFjdGlvbiIsInJ1biIsIm9wdGlvbnMiLCJkaXJlY3RvcnkiLCJTdWNjZXNzIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxTQUFTQSxVQUFVLFFBQVEsZ0NBQWdDO0FBQzNELFNBQXNCQyxjQUFjLFFBQVEsc0JBQXNCO0FBQ2xFLFNBQVNDLGNBQWMsRUFBRUMsWUFBWSxRQUFRLDBCQUEwQjtBQWN2RSxPQUFPLE1BQU1DO0lBQ1osTUFBYUMsSUFBSUMsT0FBc0IsRUFBMkI7UUFDakUsTUFBTUosZUFBZUMsYUFBYUcsUUFBUUMsU0FBUyxFQUFFRDtRQUNyRCxPQUFPTCxlQUFlTyxPQUFPLENBQUM7SUFDL0I7QUFDRCJ9

package/es6/src/webapi.command.js

@@ -0,0 +1,35 @@
+import { DecohereCommand } from "@decohere/nexus/cli";
+import { addWebapiFeatureOptions, collectName } from "./webapi/cli-options.js";
+import { WebapiAction } from "./webapi.action.js";
+export class WebapiCommand extends DecohereCommand {
+    get actions() {
+        return [
+            WebapiAction
+        ];
+    }
+    constructor(name){
+        super(name);
+        this.description("Scaffold a Cortex web API workspace");
+        this.argument("[directory]", "Target directory (default: -d or current directory)");
+        this.option("-d <directory>", "Target directory (default: current directory)", ".");
+        this.option("--name <slug>", "API name under projects/ (repeatable; default: api)", collectName, []);
+        addWebapiFeatureOptions(this);
+    }
+    /**
+	 * Commander passes positional args before options when `[directory]` is declared.
+	 * ModuleFactory expects `(opts, cmd)` — stash the directory on the command.
+	 */ action(fn) {
+        return super.action((...args)=>{
+            const cmd = args.at(-1);
+            const first = args[0];
+            const hasPositional = typeof first === "string" || first === undefined;
+            const opts = hasPositional ? args[1] : args[0];
+            if (typeof first === "string" && first !== "") {
+                cmd.setOptionValue("directory", first);
+            }
+            return fn(opts, cmd);
+        });
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,10 +1,6 @@
 {
   "name": "@decohere/scaffold",
-  "version": "0.0.1-dev.18",
-  "decohere": {
-    "dockerImageRepository": "ghcr.io/typesmiths/decohere/create",
-    "devcontainerImageRepository": "ghcr.io/typesmiths/decohere/devcontainer"
-  },
+  "version": "0.0.1-dev.80",
   "description": "Decohere project scaffolder (runs inside ghcr.io/typesmiths/decohere/create)",
   "keywords": [
     "decohere",
@@ -26,10 +22,14 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/crucible": "0.0.1-dev.5",
-    "@decohere/nexus": "0.0.1-dev.5",
+    "@decohere/crucible": "0.0.1-dev.80",
+    "@decohere/nexus": "0.0.1-dev.80",
     "commander": "^13.1.0",
     "openapi-to-postmanv2": "^5.0.0"
   },
-  "devDependencies": {}
+  "devDependencies": {},
+  "decohere": {
+    "dockerImageRepository": "ghcr.io/typesmiths/decohere/create",
+    "devcontainerImageRepository": "ghcr.io/typesmiths/decohere/devcontainer"
+  }
 }

package/types/src/add-api.action.d.ts

@@ -0,0 +1,13 @@
+import { type Action, ActionResponse } from "@decohere/nexus/cli";
+export type AddApiOptions = {
+    apiName?: string;
+    d?: string;
+    database?: string;
+    auth?: string;
+    postman?: string;
+    yes?: boolean;
+    install?: string;
+};
+export declare class AddApiAction implements Action<AddApiOptions> {
+    run(options: AddApiOptions): Promise<ActionResponse>;
+}

package/types/src/add-api.command.d.ts

@@ -0,0 +1,7 @@
+import { DecohereCommand } from "@decohere/nexus/cli";
+import { AddApiAction } from "./add-api.action.js";
+export declare class AddApiCommand extends DecohereCommand {
+    get actions(): (typeof AddApiAction)[];
+    constructor(name: string);
+    action(fn: (...args: unknown[]) => void | Promise<void>): this;
+}

package/types/src/add.command.d.ts

@@ -0,0 +1,6 @@
+import type { Actions } from "@decohere/nexus/cli";
+import { type CommandHandler, type CommandResponse, type CommandType, DecohereCommand } from "@decohere/nexus/cli";
+export declare class AddCommand extends DecohereCommand {
+    constructor(commands: Record<string, CommandType>, handler: CommandHandler);
+    run(_actions: Actions, _options: never): Promise<CommandResponse>;
+}

package/types/src/add.module.d.ts

@@ -0,0 +1,14 @@
+import { ModuleManifest } from "@decohere/nexus/cli";
+import { AddCommand } from "./add.command.js";
+import { AddApiAction } from "./add-api.action.js";
+import { AddApiCommand } from "./add-api.command.js";
+export declare class AddModule extends ModuleManifest {
+    readonly id = "add";
+    readonly command: typeof AddCommand;
+    readonly commands: {
+        api: typeof AddApiCommand;
+    };
+    readonly actions: {
+        api: typeof AddApiAction;
+    };
+}

package/types/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/types/src/create.command.d.ts

@@ -0,0 +1,6 @@
+import type { Actions } from "@decohere/nexus/cli";
+import { type CommandHandler, type CommandResponse, type CommandType, DecohereCommand } from "@decohere/nexus/cli";
+export declare class CreateCommand extends DecohereCommand {
+    constructor(commands: Record<string, CommandType>, handler: CommandHandler);
+    run(_actions: Actions, _options: never): Promise<CommandResponse>;
+}

package/types/src/create.module.d.ts

@@ -0,0 +1,14 @@
+import { ModuleManifest } from "@decohere/nexus/cli";
+import { CreateCommand } from "./create.command.js";
+import { WebapiAction } from "./webapi.action.js";
+import { WebapiCommand } from "./webapi.command.js";
+export declare class CreateModule extends ModuleManifest {
+    readonly id = "create";
+    readonly command: typeof CreateCommand;
+    readonly commands: {
+        webapi: typeof WebapiCommand;
+    };
+    readonly actions: {
+        webapi: typeof WebapiAction;
+    };
+}

package/types/src/domain/prompt.d.ts

@@ -0,0 +1,4 @@
+/** Release stdin so the process can exit after interactive prompts. */
+export declare function closePrompt(): void;
+export declare function ask(question: string, fallback?: string): Promise<string>;
+export declare function pick<T>(label: string, items: T[], display: (item: T) => string): Promise<T | null>;

package/types/src/models/compose.model.d.ts

@@ -0,0 +1,64 @@
+import type { KeyedModel } from "./source-file.js";
+export type ComposeNetworkRef = string | {
+    /** Network key under `networks:` on this service */
+    [networkKey: string]: {
+        aliases?: string[];
+    };
+};
+export interface ComposeHealthcheck {
+    test: string[];
+    interval?: string;
+    timeout?: string;
+    retries?: number;
+}
+export interface ComposeService {
+    build?: string;
+    image?: string;
+    container_name?: string;
+    /** Quoted in YAML (`0:0` must not parse as a number). */
+    user?: string;
+    env_file?: string[];
+    environment?: Record<string, string>;
+    ports?: string[];
+    volumes?: string[];
+    command?: string;
+    restart?: string;
+    depends_on?: string[];
+    /** Compose profiles (service only starts when profile is enabled). */
+    profiles?: string[];
+    /** Attach to compose networks (string name or map with aliases). */
+    networks?: ComposeNetworkRef[];
+    healthcheck?: ComposeHealthcheck;
+}
+export type ComposeNetwork = {
+    /** Fixed Docker network name (shareable across compose projects). */
+    name: string;
+    external?: boolean;
+};
+/**
+ * Live builder for `docker-compose.yml`.
+ *
+ * Features call `addService` / `addVolume` / `addNetwork` in their scaffold phases.
+ */
+export declare class DockerCompose implements KeyedModel {
+    readonly key: string;
+    private _projectName;
+    private readonly _headerComments;
+    private readonly _services;
+    private readonly _volumes;
+    private readonly _networks;
+    /** Compose project name (`name:` top-level) — isolates containers/volumes. */
+    setProjectName(name: string): this;
+    /** File-level `#` comments rendered above `name:` / `services:`. */
+    addHeaderComment(...lines: string[]): this;
+    addService(name: string, config: ComposeService): this;
+    files(): {
+        filePath: string;
+        content: string;
+    }[];
+    addVolume(name: string): this;
+    addNetwork(key: string, network: ComposeNetwork): this;
+    /** Append an env_file path to an existing service. */
+    addEnvFile(serviceName: string, filePath: string): this;
+    getContent(): string;
+}

package/types/src/models/config-yaml.model.d.ts

@@ -0,0 +1,27 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+/**
+ * Builder for a YAML config file (e.g. config/config.yaml or config/config.dev.yaml).
+ *
+ * Starts with a base section passed to the constructor. Features call
+ * `addSection(yaml)` during their scaffold phase to append their own block.
+ * `files()` joins all sections with a blank line separator.
+ */
+export declare class ConfigYaml implements KeyedModel {
+    readonly key: string;
+    private readonly filePath;
+    private readonly _sections;
+    constructor(key: string, filePath: string, baseContent: string);
+    addSection(yaml: string): this;
+    /** True when a datasource with this `name:` already appears in the file. */
+    hasDataSource(name: string): boolean;
+    hasDataSources(): boolean;
+    /**
+     * Insert a `dataSources` list item. Used by `webapi add` so we do not write a
+     * second top-level `database:` key (YAML last-key-wins).
+     */
+    appendDataSource(item: string): this;
+    static fromFile(key: string, relativePath: string, absolutePath: string): ConfigYaml;
+    files(): SourceFile[];
+}
+/** Insert a YAML list item under `dataSources:`; append a new `database:` block if missing. */
+export declare function injectYamlDataSource(yaml: string, item: string): string;

package/types/src/models/const.d.ts

@@ -0,0 +1,20 @@
+export declare const WELL_KNOWN_FILES: {
+    VSCODE_SETTINGS: string;
+    LAUNCH_JSON: string;
+    DOCKER_COMPOSE: string;
+    DEVCONTAINER_JSON: string;
+    DOCKERFILE: string;
+    PRODUCTION_DOCKERFILE: string;
+    GITHUB_CI: string;
+    PACKAGE_JSON: string;
+    API_PACKAGE_JSON: string;
+    TSCONFIG: string;
+    VITEST_CONFIG: string;
+    MAIN_TS: string;
+    CONTROLLER_TS: string;
+    CONFIG_YAML: string;
+    CONFIG_DEV_YAML: string;
+    GITIGNORE: string;
+    AUTH_CONFIG: string;
+    ENV_FILE: string;
+};

package/types/src/models/dev-container.model.d.ts

@@ -0,0 +1,37 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+/**
+ * Model for `.devcontainer/devcontainer.json`.
+ *
+ * Features call builder methods (`addExtension`, `forwardPort`, etc.) during
+ * their configure phase. `MonoRepoScaffold` calls `files()` at render time.
+ */
+export type PortAttributes = {
+    label?: string;
+    /** When true, host port must match the container port (no random remap). */
+    requireLocalPort?: boolean;
+    onAutoForward?: "notify" | "openBrowser" | "openPreview" | "silent" | "ignore";
+};
+export declare class DevContainer implements KeyedModel {
+    readonly key: string;
+    private readonly _extensions;
+    private readonly _ports;
+    private readonly _portAttributes;
+    private readonly _mounts;
+    private _postCreateCommand?;
+    private _updateContentCommand?;
+    private _postStartCommand?;
+    private _initializeCommand?;
+    private _remoteUser;
+    private _useCompose;
+    constructor();
+    addExtension(...ids: string[]): this;
+    forwardPort(...ports: number[]): this;
+    setPortAttributes(port: number, attrs: PortAttributes): this;
+    setPostCreateCommand(cmd: string): this;
+    setUpdateContentCommand(cmd: string): this;
+    setPostStartCommand(cmd: string): this;
+    setInitializeCommand(cmd: string): this;
+    setRemoteUser(user: string): this;
+    useCompose(): this;
+    files(): SourceFile[];
+}

package/types/src/models/docker-image.model.d.ts

@@ -0,0 +1,84 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+export type LayerWriter = (dockerfile: DockerfileModel) => void;
+export declare class DockerStep {
+    readonly key: string;
+    readonly content: string;
+    readonly order: number;
+    constructor(key: string, content: string, order?: number);
+    static run(key: string, command: string, order?: number): DockerStep;
+    static raw(key: string, content: string, order?: number): DockerStep;
+    static entrypoint(key: string, value: string | readonly string[], order?: number): DockerStep;
+}
+/** Named volume + paths for interactive bash history in app Dev Containers. */
+export declare const commandHistory: {
+    readonly volumeName: "bashhistory";
+    readonly dir: "/commandhistory";
+    readonly fileName: ".bash_history";
+    readonly histFile: "/commandhistory/.bash_history";
+};
+export declare function withCommandHistory(options?: {
+    historyDir?: string;
+    historyFileName?: string;
+    username?: string;
+    order?: number;
+}): LayerWriter;
+export declare function withNodeUser(options?: {
+    username?: string;
+    includeUserInstruction?: boolean;
+    order?: number;
+}): LayerWriter;
+export declare function withPnpm(options?: {
+    version?: string;
+    usernameExpr?: string;
+    order?: number;
+}): LayerWriter;
+/**
+ * Client-only (`psql`, etc.). Escalates to root so this also works when layered on
+ * a published base image that already switched to `USER node`.
+ */
+export declare function withPostgresqlClient(options?: {
+    order?: number;
+    username?: string;
+}): LayerWriter;
+/** GitHub CLI — install before USER switches away from root. */
+export declare function withGithubCli(options?: {
+    order?: number;
+}): LayerWriter;
+export declare function withWorkspaceNodeModulesOwnership(options?: {
+    workspaceDir?: string;
+    usernameExpr?: string;
+    order?: number;
+}): LayerWriter;
+export declare function withVsCodeJsDebugBootloaderFix(options?: {
+    bashrcPath?: string;
+    order?: number;
+}): LayerWriter;
+export declare class DockerfileModel implements KeyedModel {
+    readonly key: string;
+    private readonly _steps;
+    private readonly _layerWriters;
+    private _fromImage;
+    private _layerCounter;
+    constructor(baseImage: string);
+    from(baseImage: string): this;
+    addLayer(layer: LayerWriter | string, order?: 5000): this;
+    addStep(step: DockerStep): this;
+    removeStep(key: string): this;
+    entrypoint(value: string | readonly string[], order?: 10000): this;
+    addRunStep(cmd: string): this;
+    build(): string;
+    protected registerBaseLayers(): void;
+    files(): SourceFile[];
+}
+/**
+ * Shared layers for the published `ghcr.io/typesmiths/decohere/devcontainer` image.
+ * Checked in at `projects/devcontainer/Dockerfile` — keep in sync via the unit test.
+ */
+export declare class AppDevContainerBaseImage extends DockerfileModel {
+    protected registerBaseLayers(): void;
+}
+/** Generic Dev Container image helpers (history + bootloader) without webapi defaults. */
+export declare class DevContainerImageModel extends DockerfileModel {
+    protected registerBaseLayers(): void;
+    files(): SourceFile[];
+}

package/types/src/models/env-file.model.d.ts

@@ -0,0 +1,16 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+/**
+ * Accumulates key=value pairs and renders them as a `.env` file.
+ *
+ * Register once in the workspace; features call `addEntry` during their
+ * scaffold phase to contribute environment variables. The final file is
+ * written at render time when `workspace.scaffold()` is called.
+ */
+export declare class EnvFile implements KeyedModel {
+    readonly key: string;
+    private readonly _entries;
+    addEntry(key: string, value: string): this;
+    hasEntry(key: string): boolean;
+    static fromFile(absolutePath: string): EnvFile;
+    files(): SourceFile[];
+}

package/types/src/models/gitignore.model.d.ts

@@ -0,0 +1,7 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+export declare class Gitignore implements KeyedModel {
+    readonly key: string;
+    private ignoreList;
+    add(...patterns: string[]): this;
+    files(): SourceFile[];
+}

package/types/src/models/launch-json.model.d.ts

@@ -0,0 +1,7 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+export declare class LaunchJson implements KeyedModel {
+    private readonly apiNames;
+    readonly key: string;
+    constructor(apiNames?: readonly string[]);
+    files(): SourceFile[];
+}

package/types/src/models/package-json.model.d.ts

@@ -0,0 +1,35 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+export type PackageJsonOptions = {
+    startEntry?: string;
+    /** API slugs in this workspace. Drives `start:<name>` / `dev:<name>`. */
+    apiNames?: readonly string[];
+    /** Host workspace name used in `@<workspace>/<api>` for flux `--project`. */
+    workspaceName?: string;
+};
+/**
+ * Builder for the root `package.json`.
+ *
+ * Starts with the core API dependencies. Features call `addDependency` /
+ * `addDevDependency` during their scaffold phase to inject their own deps
+ * before `files()` is called at render time.
+ */
+export declare class PackageJson implements KeyedModel {
+    private readonly name;
+    readonly key: string;
+    private _dependencies;
+    private _devDependencies;
+    private _scripts;
+    private _version;
+    private _type;
+    private _rest;
+    constructor(name: string, options?: PackageJsonOptions);
+    /** Load an existing root package.json so `webapi add` can merge scripts/deps. */
+    static fromFile(filePath: string): PackageJson;
+    addDependency(name: string, version: string): this;
+    addDevDependency(name: string, version: string): this;
+    addScript(name: string, command: string): this;
+    hasScript(name: string): boolean;
+    files(): SourceFile[];
+}
+/** Stable A→Z key order for package.json dependency maps. */
+export declare function sortStringMap(map: Record<string, string>): Record<string, string>;