@apso/cli 0.14.0 → 0.15.1

package/dist/commands/config.js

@@ -13,11 +13,11 @@ const VALID_KEYS = [
     "telemetryDisabled",
     "defaultWorkspace",
 ];
-const BOOLEAN_KEYS = [
+const BOOLEAN_KEYS = new Set([
     "verbose",
     "noColor",
     "telemetryDisabled",
-];
+]);
 function parseBoolean(value) {
     const lower = value.toLowerCase();
     if (lower === "true" || lower === "1")
@@ -62,7 +62,7 @@ class Config extends base_command_1.default {
             if (!VALID_KEYS.includes(key)) {
                 this.error(`Unknown key: ${key}\nValid keys: ${VALID_KEYS.join(", ")}`);
             }
-            if (BOOLEAN_KEYS.includes(key)) {
+            if (BOOLEAN_KEYS.has(key)) {
                 const boolVal = parseBoolean(value);
                 if (boolVal === null) {
                     this.error(`Invalid boolean value: ${value}. Use true/false or 1/0.`);

package/dist/commands/dev.d.ts

@@ -3,13 +3,66 @@ export default class Dev extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        docker: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         detach: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         build: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
+    private children;
+    private cleanup;
     run(): Promise<void>;
     /**
-     * Detect whether to use `docker compose` (v2 plugin) or `docker-compose` (v1).
-     * Returns the command parts as an array.
+     * TypeScript: run `npm run dev` which reads DATABASE_TYPE from .env.
+     * PGlite is handled natively by the NestJS app -- no sidecar needed.
+     */
+    private runTypeScript;
+    /**
+     * Python: if pglite, start the pglite-server sidecar first, then uvicorn.
+     */
+    private runPython;
+    /**
+     * Go: if pglite, start the pglite-server sidecar first, then go run.
+     */
+    private runGo;
+    /**
+     * Fallback: run docker compose up (the old behavior).
+     */
+    private runDocker;
+    /**
+     * Detect the project language from .apsorc.
+     * Falls back to typescript if not specified.
+     */
+    private detectLanguage;
+    /**
+     * Read DATABASE_TYPE from .env. Defaults to pglite.
+     */
+    private readDatabaseType;
+    /**
+     * Read a single value from .env.
+     */
+    private readEnvValue;
+    /**
+     * Find .apsorc by walking up from cwd.
+     */
+    private findApsorc;
+    /**
+     * Run `npm install` if node_modules doesn't exist.
+     * Needed for the pglite-server sidecar in Python/Go projects.
+     */
+    private ensureNodeModules;
+    /**
+     * Wait for a TCP port to become reachable.
+     */
+    private waitForPort;
+    /**
+     * Spawn a process in the background and track it for cleanup.
+     */
+    private spawnBackground;
+    /**
+     * Spawn a process and wait for it to exit.
+     */
+    private spawnAndWait;
+    /**
+     * Detect whether to use `docker compose` (v2) or `docker-compose` (v1).
      */
     private detectComposeVariant;
 }

package/dist/commands/dev.js

@@ -4,61 +4,247 @@ const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
 const child_process_1 = require("child_process");
 const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
 const shelljs_1 = tslib_1.__importDefault(require("shelljs"));
 const base_command_1 = tslib_1.__importDefault(require("../lib/base-command"));
 class Dev extends base_command_1.default {
+    constructor() {
+        super(...arguments);
+        this.children = [];
+        this.cleanup = () => {
+            for (const child of this.children) {
+                child.kill("SIGTERM");
+            }
+        };
+    }
     async run() {
         const { flags } = await this.parse(Dev);
-        // Check Docker is installed
+        if (flags.docker) {
+            return this.runDocker(flags);
+        }
+        const language = this.detectLanguage();
+        const databaseType = this.readDatabaseType();
+        this.log(`Detected language: ${language}`);
+        this.log(`Database type: ${databaseType}`);
+        // Set up signal forwarding for clean shutdown
+        process.on("SIGINT", this.cleanup);
+        process.on("SIGTERM", this.cleanup);
+        try {
+            switch (language) {
+                case "typescript":
+                    await this.runTypeScript();
+                    break;
+                case "python":
+                    await this.runPython(databaseType);
+                    break;
+                case "go":
+                    await this.runGo(databaseType);
+                    break;
+                default:
+                    this.error(`Unsupported language: ${language}. Supported: typescript, python, go.`);
+            }
+        }
+        finally {
+            process.removeListener("SIGINT", this.cleanup);
+            process.removeListener("SIGTERM", this.cleanup);
+        }
+    }
+    /**
+     * TypeScript: run `npm run dev` which reads DATABASE_TYPE from .env.
+     * PGlite is handled natively by the NestJS app -- no sidecar needed.
+     */
+    async runTypeScript() {
+        this.log("Starting TypeScript dev server...");
+        await this.spawnAndWait("npm", ["run", "dev"]);
+    }
+    /**
+     * Python: if pglite, start the pglite-server sidecar first, then uvicorn.
+     */
+    async runPython(databaseType) {
+        if (databaseType === "pglite") {
+            this.log("Starting PGlite sidecar...");
+            await this.ensureNodeModules();
+            this.spawnBackground("npm", ["run", "db"]);
+            // Give the sidecar a moment to bind the port
+            await this.waitForPort(5432, 10000);
+        }
+        this.log("Starting Python dev server...");
+        await this.spawnAndWait("uvicorn", [
+            "app.main:app",
+            "--reload",
+            "--host",
+            "0.0.0.0",
+            "--port",
+            this.readEnvValue("PORT") || "3000",
+        ]);
+    }
+    /**
+     * Go: if pglite, start the pglite-server sidecar first, then go run.
+     */
+    async runGo(databaseType) {
+        if (databaseType === "pglite") {
+            this.log("Starting PGlite sidecar...");
+            await this.ensureNodeModules();
+            this.spawnBackground("npm", ["run", "db"]);
+            await this.waitForPort(5432, 10000);
+        }
+        this.log("Starting Go dev server...");
+        await this.spawnAndWait("go", ["run", "cmd/main.go"]);
+    }
+    /**
+     * Fallback: run docker compose up (the old behavior).
+     */
+    async runDocker(flags) {
         if (!shelljs_1.default.which("docker")) {
             this.error("Docker is required but not found. Please install Docker and try again.\nhttps://docs.docker.com/get-docker/");
         }
-        // Detect compose variant (v2 plugin vs v1 standalone)
         const composeCmd = this.detectComposeVariant();
-        // Verify docker-compose.yml exists
         if (!fs.existsSync("docker-compose.yml")) {
             this.error("No docker-compose.yml found in the current directory.\nMake sure you are in an Apso project root.");
         }
-        // Build the command args
         const args = [...composeCmd, "up"];
-        if (flags.build) {
+        if (flags.build)
             args.push("--build");
-        }
-        if (flags.detach) {
+        if (flags.detach)
             args.push("-d");
-        }
         this.log(`Running: ${args.join(" ")}`);
-        const child = (0, child_process_1.spawn)(args[0], args.slice(1), {
+        await this.spawnAndWait(args[0], args.slice(1), {
+            AUTH_DISABLED: "true",
+        });
+    }
+    // --- Helpers ---
+    /**
+     * Detect the project language from .apsorc.
+     * Falls back to typescript if not specified.
+     */
+    detectLanguage() {
+        const apsorcPath = this.findApsorc();
+        if (!apsorcPath) {
+            this.log("No .apsorc found, defaulting to typescript.");
+            return "typescript";
+        }
+        try {
+            // eslint-disable-next-line unicorn/prefer-json-parse-buffer -- TS types JSON.parse as string-only
+            const content = fs.readFileSync(apsorcPath, "utf-8");
+            const config = JSON.parse(content);
+            return config.language || "typescript";
+        }
+        catch {
+            this.log("Could not parse .apsorc, defaulting to typescript.");
+            return "typescript";
+        }
+    }
+    /**
+     * Read DATABASE_TYPE from .env. Defaults to pglite.
+     */
+    readDatabaseType() {
+        return this.readEnvValue("DATABASE_TYPE") || "pglite";
+    }
+    /**
+     * Read a single value from .env.
+     */
+    readEnvValue(key) {
+        const envPath = path.resolve(".env");
+        if (!fs.existsSync(envPath))
+            return undefined;
+        const content = fs.readFileSync(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("#") || !trimmed.includes("="))
+                continue;
+            const [k, ...rest] = trimmed.split("=");
+            if (k.trim() === key)
+                return rest.join("=").trim();
+        }
+        return undefined;
+    }
+    /**
+     * Find .apsorc by walking up from cwd.
+     */
+    findApsorc() {
+        let dir = process.cwd();
+        while (dir !== path.parse(dir).root) {
+            const candidate = path.join(dir, ".apsorc");
+            if (fs.existsSync(candidate))
+                return candidate;
+            dir = path.dirname(dir);
+        }
+        return null;
+    }
+    /**
+     * Run `npm install` if node_modules doesn't exist.
+     * Needed for the pglite-server sidecar in Python/Go projects.
+     */
+    async ensureNodeModules() {
+        if (!fs.existsSync("node_modules")) {
+            this.log("Installing pglite-server dependencies...");
+            await this.spawnAndWait("npm", ["install"]);
+        }
+    }
+    /**
+     * Wait for a TCP port to become reachable.
+     */
+    waitForPort(port, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const start = Date.now();
+            const check = () => {
+                const net = require("net");
+                const sock = net.createConnection({ port, host: "127.0.0.1" }, () => {
+                    sock.destroy();
+                    resolve();
+                });
+                sock.on("error", () => {
+                    sock.destroy();
+                    if (Date.now() - start > timeoutMs) {
+                        reject(new Error(`Port ${port} did not become available within ${timeoutMs}ms`));
+                    }
+                    else {
+                        setTimeout(check, 250);
+                    }
+                });
+            };
+            check();
+        });
+    }
+    /**
+     * Spawn a process in the background and track it for cleanup.
+     */
+    spawnBackground(cmd, args) {
+        const child = (0, child_process_1.spawn)(cmd, args, {
             stdio: "inherit",
-            env: {
-                ...process.env,
-                AUTH_DISABLED: "true",
-            },
+            env: { ...process.env },
         });
-        // Forward signals for clean shutdown
-        const forwardSignal = (signal) => {
-            child.kill(signal);
-        };
-        process.on("SIGINT", forwardSignal);
-        process.on("SIGTERM", forwardSignal);
+        this.children.push(child);
+        child.on("error", (err) => {
+            this.warn(`Background process ${cmd} failed: ${err.message}`);
+        });
+        return child;
+    }
+    /**
+     * Spawn a process and wait for it to exit.
+     */
+    spawnAndWait(cmd, args, extraEnv) {
         return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(cmd, args, {
+                stdio: "inherit",
+                env: { ...process.env, ...extraEnv },
+            });
+            this.children.push(child);
             child.on("close", (code) => {
-                process.removeListener("SIGINT", forwardSignal);
-                process.removeListener("SIGTERM", forwardSignal);
+                this.children = this.children.filter((c) => c !== child);
                 if (code !== 0 && code !== null) {
-                    reject(new Error(`docker compose exited with code ${code}`));
+                    reject(new Error(`${cmd} exited with code ${code}`));
                     return;
                 }
                 resolve();
             });
             child.on("error", (err) => {
-                this.error(`Failed to start Docker Compose: ${err.message}`);
+                this.error(`Failed to start ${cmd}: ${err.message}`);
             });
         });
     }
     /**
-     * Detect whether to use `docker compose` (v2 plugin) or `docker-compose` (v1).
-     * Returns the command parts as an array.
+     * Detect whether to use `docker compose` (v2) or `docker-compose` (v1).
      */
     detectComposeVariant() {
         try {
@@ -66,7 +252,6 @@ class Dev extends base_command_1.default {
             return ["docker", "compose"];
         }
         catch {
-            // Fall back to v1
             if (shelljs_1.default.which("docker-compose")) {
                 return ["docker-compose"];
             }
@@ -74,21 +259,24 @@ class Dev extends base_command_1.default {
         }
     }
 }
-Dev.description = "Start the local development server using Docker Compose";
+Dev.description = "Start the local development server. Detects project language and database type from .apsorc and .env.";
 Dev.examples = [
     `$ apso dev`,
-    `$ apso dev --build`,
-    `$ apso dev --detach`,
-    `$ apso dev --build --detach`,
+    `$ apso dev --docker`,
+    `$ apso dev --docker --build`,
 ];
 Dev.flags = {
+    docker: core_1.Flags.boolean({
+        description: "Use Docker Compose instead of the native dev stack",
+        default: false,
+    }),
     detach: core_1.Flags.boolean({
         char: "d",
-        description: "Run containers in the background",
+        description: "Run containers in the background (Docker mode only)",
         default: false,
     }),
     build: core_1.Flags.boolean({
-        description: "Rebuild images before starting",
+        description: "Rebuild images before starting (Docker mode only)",
         default: false,
     }),
 };

package/dist/commands/init.js

@@ -24,12 +24,7 @@ class Init extends base_command_1.default {
             this.error("An Apso project already exists in this directory. Run commands from a different directory or remove .apsorc / .apso/link.json first.");
         }
         const isAuthenticated = !flags["skip-platform"] && config_1.credentials.isValid();
-        if (isAuthenticated) {
-            await this.runAuthenticated(flags);
-        }
-        else {
-            await this.runOffline(flags);
-        }
+        await (isAuthenticated ? this.runAuthenticated(flags) : this.runOffline(flags));
     }
     async runAuthenticated(flags) {
         // Ask: create new or clone existing
@@ -44,18 +39,13 @@ class Init extends base_command_1.default {
                 ],
             },
         ]);
-        if (action === "clone") {
-            await this.cloneExisting();
-        }
-        else {
-            await this.createNew(flags);
-        }
+        await (action === "clone" ? this.cloneExisting() : this.createNew(flags));
     }
     async cloneExisting() {
         // Select workspace
         const workspaces = await services_1.workspacesApi.list();
         if (workspaces.length === 0) {
-            this.error("No workspaces found. Create a workspace at https://app.apso.ai first.");
+            this.error("No workspaces found. Create a workspace at https://app.apso.cloud first.");
         }
         const { workspace } = await inquirer_1.default.prompt([
             {
@@ -170,7 +160,7 @@ class Init extends base_command_1.default {
         // Select workspace
         const workspaces = await services_1.workspacesApi.list();
         if (workspaces.length === 0) {
-            this.error("No workspaces found. Create a workspace at https://app.apso.ai first.");
+            this.error("No workspaces found. Create a workspace at https://app.apso.cloud first.");
         }
         const { workspace } = await inquirer_1.default.prompt([
             {

package/dist/commands/link.js

@@ -44,7 +44,7 @@ class Link extends base_command_1.default {
         else {
             const workspaces = await services_1.workspacesApi.list();
             if (workspaces.length === 0) {
-                this.error("No workspaces found. Create a workspace at https://app.apso.ai first.");
+                this.error("No workspaces found. Create a workspace at https://app.apso.cloud first.");
             }
             const response = await inquirer_1.default.prompt([
                 {

package/dist/commands/login.js

@@ -154,7 +154,7 @@ class Login extends base_command_1.default {
             });
             this.log(`Logged in as ${profile.email}`);
         }
-        catch (error) {
+        catch {
             config_1.credentials.clear();
             this.error("Invalid token. Please check your token and try again.");
         }

package/dist/commands/mcp/serve.js

@@ -4,7 +4,9 @@ const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
 const fs = tslib_1.__importStar(require("fs"));
 const path = tslib_1.__importStar(require("path"));
+// eslint-disable-next-line node/no-missing-import -- eslint-plugin-node cannot resolve package "exports" subpaths
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+// eslint-disable-next-line node/no-missing-import -- eslint-plugin-node cannot resolve package "exports" subpaths
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const zod_1 = require("zod");
 const base_command_1 = tslib_1.__importDefault(require("../../lib/base-command"));
@@ -233,7 +235,7 @@ class McpServe extends base_command_1.default {
                 .boolean()
                 .optional()
                 .describe("Skip code formatting after generation (default: false)"),
-        }, async ({ language, skip_format }) => {
+        }, async ({ language }) => {
             try {
                 const configPath = (0, apsorc_parser_1.findConfigPath)();
                 if (!configPath) {
@@ -301,12 +303,14 @@ class McpServe extends base_command_1.default {
                 const enumFiles = await generator.generateEnums(entities, lowerCaseApiType);
                 for (const file of enumFiles) {
                     const fullPath = path.join(autogenPath, file.path);
+                    // eslint-disable-next-line no-await-in-loop
                     await (0, file_system_1.createFile)(fullPath, file.content);
                     filesGenerated.push(file.path);
                 }
                 // Generate per-entity files
                 for (const entity of entities) {
                     const entityRelationships = relationshipMap[entity.name] || [];
+                    // eslint-disable-next-line no-await-in-loop
                     const allFiles = await Promise.all([
                         generator.generateEntity({
                             entity,
@@ -344,6 +348,7 @@ class McpServe extends base_command_1.default {
                     for (const files of allFiles) {
                         for (const file of files) {
                             const fullPath = path.join(autogenPath, file.path);
+                            // eslint-disable-next-line no-await-in-loop
                             await (0, file_system_1.createFile)(fullPath, file.content);
                             filesGenerated.push(file.path);
                         }
@@ -353,6 +358,7 @@ class McpServe extends base_command_1.default {
                 const guardFiles = await generator.generateGuards(entities, auth);
                 for (const file of guardFiles) {
                     const fullPath = path.join(autogenPath, file.path);
+                    // eslint-disable-next-line no-await-in-loop
                     await (0, file_system_1.createFile)(fullPath, file.content);
                     filesGenerated.push(file.path);
                 }
@@ -360,6 +366,7 @@ class McpServe extends base_command_1.default {
                 const indexFiles = await generator.generateIndexModule(entities, lowerCaseApiType);
                 for (const file of indexFiles) {
                     const fullPath = path.join(autogenPath, file.path);
+                    // eslint-disable-next-line no-await-in-loop
                     await (0, file_system_1.createFile)(fullPath, file.content);
                     filesGenerated.push(file.path);
                 }

package/dist/commands/migrate.js

@@ -75,6 +75,7 @@ class Migrate extends base_command_1.default {
                 });
                 for (const file of migrationFiles) {
                     const fullPath = path.join(process.cwd(), file.path);
+                    // eslint-disable-next-line no-await-in-loop
                     await (0, file_system_1.createFile)(fullPath, file.content);
                     this.log(`Generated migration file: ${file.path}`);
                 }

package/dist/commands/projects.js

@@ -28,7 +28,7 @@ class Projects extends base_command_1.default {
                 // Prompt
                 const workspaces = await services_1.workspacesApi.list();
                 if (workspaces.length === 0) {
-                    this.error("No workspaces found. Create a workspace at https://app.apso.ai first.");
+                    this.error("No workspaces found. Create a workspace at https://app.apso.cloud first.");
                 }
                 const response = await inquirer_1.default.prompt([
                     {

package/dist/commands/schema/diff.js

@@ -8,9 +8,9 @@ const apsorc_parser_1 = require("../../lib/apsorc-parser");
 const schema_convert_1 = require("../../lib/utils/schema-convert");
 // Inline ANSI color helpers (no dependency needed)
 const useColor = () => !config_1.globalConfig.read().noColor;
-const green = (s) => useColor() ? `\x1b[32m${s}\x1b[0m` : s;
-const red = (s) => useColor() ? `\x1b[31m${s}\x1b[0m` : s;
-const yellow = (s) => useColor() ? `\x1b[33m${s}\x1b[0m` : s;
+const green = (s) => useColor() ? `\u001B[32m${s}\u001B[0m` : s;
+const red = (s) => useColor() ? `\u001B[31m${s}\u001B[0m` : s;
+const yellow = (s) => useColor() ? `\u001B[33m${s}\u001B[0m` : s;
 class SchemaDiff extends base_command_1.default {
     async run() {
         // Auth guard

package/dist/lib/config/types.js

@@ -11,8 +11,8 @@ exports.CONFIG_ENV_VARS = exports.DEFAULT_GLOBAL_CONFIG = void 0;
  * Default values for global configuration
  */
 exports.DEFAULT_GLOBAL_CONFIG = {
-    apiUrl: "https://api.apso.ai",
-    webUrl: "https://app.apso.ai",
+    apiUrl: "https://api.apso.dev",
+    webUrl: "https://app.apso.cloud",
     verbose: false,
     noColor: false,
     telemetryDisabled: false,

package/dist/lib/doctor/checks.js

@@ -40,7 +40,7 @@ function checkPkStrategy(ctx) {
         }
         const content = fs.readFileSync(entityPath, "utf-8");
         // The correct pattern is @PrimaryGeneratedColumn('uuid')
-        const hasPrimaryGenerated = /PrimaryGeneratedColumn\s*\(\s*['"]uuid['"]\s*\)/.test(content);
+        const hasPrimaryGenerated = /PrimaryGeneratedColumn\s*\(\s*["']uuid["']\s*\)/.test(content);
         // Wrong patterns: @PrimaryColumn() or @PrimaryColumn({ type: 'uuid' }) without generation
         const hasPrimaryColumnOnly = /PrimaryColumn\s*\(/.test(content) && !hasPrimaryGenerated;
         if (hasPrimaryColumnOnly) {
@@ -87,7 +87,7 @@ function checkUnusedImports(ctx) {
         const lines = content.split("\n");
         // Find import lines from typeorm
         for (const line of lines) {
-            const importMatch = line.match(/import\s*\{([^}]+)\}\s*from\s*['"]typeorm['"]/);
+            const importMatch = line.match(/import\s*{([^}]+)}\s*from\s*["']typeorm["']/);
             if (!importMatch)
                 continue;
             const imports = importMatch[1]

package/dist/lib/generators/go.js

@@ -285,7 +285,7 @@ class GoGenerator extends base_1.BaseGenerator {
         }
         const timestamp = new Date()
             .toISOString()
-            .replace(/[-:T]/g, "")
+            .replace(/[:T-]/g, "")
             .slice(0, 14);
         const name = migrationName || "auto";
         const filename = `${timestamp}_${name}.sql`;
@@ -346,9 +346,6 @@ ${downStatements}
             entities: entitiesData,
         });
         // Generate model registry for AutoMigrate support
-        const modelImports = entities
-            .map((e) => `\t// ${e.name} model`)
-            .join("\n");
         const modelRefs = entities
             .map((e) => `\t\t&${(0, casing_1.pascalCase)(e.name)}{},`)
             .join("\n");

package/dist/lib/generators/python.js

@@ -213,7 +213,7 @@ class PythonGenerator extends base_1.BaseGenerator {
         }
         const timestamp = new Date()
             .toISOString()
-            .replace(/[-:T]/g, "")
+            .replace(/[:T-]/g, "")
             .slice(0, 14);
         const revision = timestamp;
         const name = migrationName || "auto";

package/dist/lib/migrate/sandbox.js

@@ -12,12 +12,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetSandbox = exports.applyMigration = exports.runMigrationSandbox = void 0;
 const tslib_1 = require("tslib");
+/* eslint-disable new-cap -- TypeORM decorator factories (Entity, Column, ...) are applied programmatically */
 const fs = tslib_1.__importStar(require("fs"));
 const path = tslib_1.__importStar(require("path"));
 const paths_1 = require("../config/paths");
 const snapshot_1 = require("./snapshot");
 const field_1 = require("../utils/field");
 const casing_1 = require("../utils/casing");
+const relationships_1 = require("../utils/relationships");
 /**
  * Get the sandbox data directory for PGlite persistence.
  */
@@ -57,11 +59,12 @@ async function resetPGliteSingleton() {
  * Clears TypeORM's global metadata storage first to prevent cross-contamination
  * between runs.
  */
-function buildEntityClasses(entities) {
-    var _a, _b;
+function buildEntityClasses(entities, relationshipMap = {}) {
+    var _a, _b, _c;
     clearTypeOrmMetadata();
     const typeorm = require("typeorm");
     const classes = [];
+    const classMap = new Map();
     for (const entityDef of entities) {
         const className = entityDef.name;
         const tableName = (0, casing_1.snakeCase)(entityDef.name);
@@ -108,7 +111,7 @@ function buildEntityClasses(entities) {
             if (field.type === "enum" && field.values) {
                 colOpts.enum = field.values;
             }
-            if (field.length)
+            if (((_c = field.length) !== null && _c !== void 0 ? _c : 0) > 0)
                 colOpts.length = field.length;
             if (field.precision)
                 colOpts.precision = field.precision;
@@ -122,9 +125,125 @@ function buildEntityClasses(entities) {
             }
         }
         classes.push(EntityClass);
+        classMap.set(entityDef.name, EntityClass);
+    }
+    for (const entityDef of entities) {
+        const EntityClass = classMap.get(entityDef.name);
+        if (!EntityClass)
+            continue;
+        const relationships = (0, relationships_1.getRelationshipForTemplate)(entityDef.name, relationshipMap[entityDef.name] || [], entities);
+        for (const relationship of relationships) {
+            const targetClass = classMap.get(relationship.name);
+            if (!targetClass)
+                continue;
+            const inversePropertyName = relationship.inverseSidePropertyName ||
+                relationship.inversePropertyName ||
+                entityDef.name;
+            const relationOptions = {};
+            if (relationship.nullable !== undefined) {
+                relationOptions.nullable = relationship.nullable;
+            }
+            if (relationship.cascadeDelete) {
+                relationOptions.onDelete = "CASCADE";
+            }
+            if (relationship.type === "ManyToOne") {
+                if (relationship.index) {
+                    typeorm.Index()(EntityClass.prototype, relationship.relationshipName);
+                }
+                const inverseSide = relationship.biDirectional
+                    ? (target) => target[inversePropertyName]
+                    : undefined;
+                typeorm.ManyToOne(() => targetClass, inverseSide, relationOptions)(EntityClass.prototype, relationship.relationshipName);
+                typeorm.JoinColumn({ name: relationship.camelCasedId })(EntityClass.prototype, relationship.relationshipName);
+            }
+            if (relationship.type === "OneToMany" && relationship.biDirectional) {
+                typeorm.OneToMany(() => targetClass, (target) => target[inversePropertyName])(EntityClass.prototype, relationship.pluralizedRelationshipName);
+            }
+            if (relationship.type === "ManyToMany") {
+                const inverseSide = relationship.biDirectional
+                    ? (target) => target[inversePropertyName]
+                    : undefined;
+                typeorm.ManyToMany(() => targetClass, inverseSide)(EntityClass.prototype, relationship.pluralizedRelationshipName);
+                if (relationship.joinTable) {
+                    const joinTableOptions = {};
+                    if (relationship.joinTableName) {
+                        joinTableOptions.name = relationship.joinTableName;
+                    }
+                    if (relationship.joinColumnName) {
+                        joinTableOptions.joinColumn = {
+                            name: relationship.joinColumnName,
+                            referencedColumnName: "id",
+                        };
+                    }
+                    if (relationship.inverseJoinColumnName) {
+                        joinTableOptions.inverseJoinColumn = {
+                            name: relationship.inverseJoinColumnName,
+                            referencedColumnName: "id",
+                        };
+                    }
+                    typeorm.JoinTable(Object.keys(joinTableOptions).length > 0
+                        ? joinTableOptions
+                        : undefined)(EntityClass.prototype, relationship.pluralizedRelationshipName);
+                }
+            }
+            if (relationship.type === "OneToOne") {
+                const inverseSide = relationship.biDirectional
+                    ? (target) => target[inversePropertyName]
+                    : undefined;
+                typeorm.OneToOne(() => targetClass, inverseSide, relationOptions)(EntityClass.prototype, relationship.relationshipName);
+                if (relationship.joinTable) {
+                    typeorm.JoinColumn()(EntityClass.prototype, relationship.relationshipName);
+                }
+            }
+        }
     }
     return classes;
 }
+function snapshotRelationships(relationshipMap) {
+    return Object.entries(relationshipMap)
+        .flatMap(([from, relationships]) => relationships.map((relationship) => {
+        var _a;
+        return ({
+            from,
+            to: relationship.name,
+            type: relationship.type,
+            to_name: (_a = relationship.referenceName) !== null && _a !== void 0 ? _a : undefined,
+            nullable: relationship.nullable,
+            bi_directional: relationship.biDirectional,
+            cascadeDelete: relationship.cascadeDelete,
+            index: relationship.index,
+            join: relationship.join,
+            joinTableName: relationship.joinTableName,
+            joinColumnName: relationship.joinColumnName,
+            inverseJoinColumnName: relationship.inverseJoinColumnName,
+            inverseReferenceName: relationship.inverseReferenceName,
+        });
+    }))
+        .sort((a, b) => `${a.from}:${a.to}:${a.type}:${a.to_name || ""}`.localeCompare(`${b.from}:${b.to}:${b.type}:${b.to_name || ""}`));
+}
+function relationshipMapFromSnapshot(relationships = []) {
+    const relationshipMap = {};
+    for (const relationship of relationships) {
+        relationshipMap[relationship.from] = [
+            ...(relationshipMap[relationship.from] || []),
+            {
+                name: relationship.to,
+                type: relationship.type,
+                referenceName: relationship.to_name,
+                nullable: relationship.nullable,
+                biDirectional: relationship.bi_directional,
+                cascadeDelete: relationship.cascadeDelete,
+                index: relationship.index,
+                join: relationship.join,
+                joinTableName: relationship.joinTableName,
+                joinColumnName: relationship.joinColumnName,
+                inverseJoinColumnName: relationship.inverseJoinColumnName,
+                inverseReferenceName: relationship.inverseReferenceName,
+            },
+        ];
+    }
+    return relationshipMap;
+}
 /**
  * Create a TypeORM DataSource configured for PGlite with in-memory entity classes.
  */
@@ -135,10 +254,10 @@ async function createPGliteDataSource(entityClasses) {
         const pgliteModule = await Promise.resolve().then(() => tslib_1.__importStar(require("typeorm-pglite")));
         PGliteDriver = pgliteModule.PGliteDriver;
     }
-    catch (e) {
+    catch (error) {
         throw new Error("Migration sandbox requires typeorm-pglite and @electric-sql/pglite.\n" +
             "Install them with: npm install typeorm @electric-sql/pglite typeorm-pglite\n" +
-            `Original error: ${e instanceof Error ? e.message : e}`);
+            `Original error: ${error instanceof Error ? error.message : error}`);
     }
     // Create a driver. typeorm-pglite uses a singleton PGliteInstance
     // so multiple DataSources share the same in-process database.
@@ -185,6 +304,7 @@ async function runMigrationSandbox(current, projectDir) {
                 scopeBy: e.scopeBy,
             });
         }),
+        relationships: snapshotRelationships(current.relationshipMap),
     };
     // Quick check: has anything changed?
     if (snapshot && !schemaChanged(currentSnapshot, snapshot)) {
@@ -221,7 +341,7 @@ async function runMigrationSandbox(current, projectDir) {
             : [];
         // Step 1: Establish baseline with previous schema
         if (previousEntities.length > 0) {
-            const prevClasses = buildEntityClasses(previousEntities);
+            const prevClasses = buildEntityClasses(previousEntities, relationshipMapFromSnapshot(snapshot === null || snapshot === void 0 ? void 0 : snapshot.relationships));
             const prevDs = await createPGliteDataSource(prevClasses);
             await prevDs.initialize();
             await prevDs.synchronize();
@@ -230,7 +350,7 @@ async function runMigrationSandbox(current, projectDir) {
             // The PGlite in-memory database persists in the singleton.
         }
         // Step 2: Compute diff with current schema
-        const currentClasses = buildEntityClasses(current.entities);
+        const currentClasses = buildEntityClasses(current.entities, current.relationshipMap);
         const currentDs = await createPGliteDataSource(currentClasses);
         await currentDs.initialize();
         try {
@@ -275,7 +395,9 @@ async function runMigrationSandbox(current, projectDir) {
         try {
             await resetPGliteSingleton();
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         return {
             needed: true,
             success: false,
@@ -314,6 +436,7 @@ function applyMigration(current, projectDir) {
                 scopeBy: e.scopeBy,
             });
         }),
+        relationships: snapshotRelationships(current.relationshipMap),
     };
     (0, snapshot_1.writeSnapshot)(snapshot, projectDir);
 }
@@ -333,5 +456,7 @@ exports.resetSandbox = resetSandbox;
  * Simple deep comparison between current and snapshot schemas.
  */
 function schemaChanged(current, snapshot) {
-    return (JSON.stringify(current.entities) !== JSON.stringify(snapshot.entities));
+    return (JSON.stringify(current.entities) !== JSON.stringify(snapshot.entities) ||
+        JSON.stringify(current.relationships || []) !==
+            JSON.stringify(snapshot.relationships || []));
 }

package/dist/lib/migrate/snapshot.d.ts

@@ -57,6 +57,7 @@ export interface ComparableSchema {
         updated_at?: boolean;
         scopeBy?: string | string[];
     }>;
+    relationships?: ApsorcSnapshot["relationships"];
 }
 /**
  * Read the saved schema snapshot, or null if none exists.
@@ -70,11 +71,4 @@ export declare function writeSnapshot(schema: ApsorcSnapshot, projectDir?: strin
  * Delete the snapshot and sandbox directory contents (for --reset).
  */
 export declare function resetSnapshot(projectDir?: string): void;
-/**
- * Detect whether the current schema differs from the stored snapshot.
- *
- * Compares entity names, field definitions, and relationships using
- * deterministic JSON serialization. Returns true if any change is detected,
- * or if no snapshot exists (first run).
- */
 export declare function hasChanges(current: ComparableSchema, snapshot: ApsorcSnapshot | null): boolean;

package/dist/lib/migrate/snapshot.js

@@ -27,6 +27,7 @@ function readSnapshot(projectDir) {
         return null;
     }
     try {
+        // eslint-disable-next-line unicorn/prefer-json-parse-buffer -- TS types JSON.parse as string-only
         const content = fs.readFileSync(snapshotPath, "utf8");
         return JSON.parse(content);
     }
@@ -62,11 +63,11 @@ exports.resetSnapshot = resetSnapshot;
  * deterministic JSON serialization. Returns true if any change is detected,
  * or if no snapshot exists (first run).
  */
+const normalize = (obj) => JSON.stringify(obj);
 function hasChanges(current, snapshot) {
     if (!snapshot) {
         return true;
     }
-    const normalize = (obj) => JSON.stringify(obj);
     // Compare entity count
     if (current.entities.length !== snapshot.entities.length) {
         return true;
@@ -95,6 +96,9 @@ function hasChanges(current, snapshot) {
             return true;
         }
     }
+    if (normalize(current.relationships || []) !== normalize(snapshot.relationships || [])) {
+        return true;
+    }
     return false;
 }
 exports.hasChanges = hasChanges;

package/dist/lib/templates/entities/entity-col-bigint.eta

@@ -1,6 +1,6 @@
 <% const {field} = it; %>
 
-@Column({ "type": "bigint"<% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
+@Column({ "type": "bigint", nullable: <%= Boolean(field.nullable) %><% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
 <% if (field.index ) {%>
 @Index()
 <% } %>

package/dist/lib/templates/entities/entity-col-decimal.eta

@@ -1,6 +1,6 @@
 <% const {field} = it; %>
 
-@Column({ "type": "decimal", precision: <%= field.precision || 10 %>, scale: <%= field.scale || 2 %><% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
+@Column({ "type": "decimal", precision: <%= field.precision || 10 %>, scale: <%= field.scale || 2 %>, nullable: <%= Boolean(field.nullable) %><% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
 <% if (field.index ) {%>
 @Index()
 <% } %>

package/dist/lib/templates/entities/entity-col-double.eta

@@ -1,6 +1,6 @@
 <% const {field} = it; %>
 
-@Column({ "type": "float8"<% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
+@Column({ "type": "float8", nullable: <%= Boolean(field.nullable) %><% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
 <% if (field.index ) {%>
 @Index()
 <% } %>

package/dist/lib/templates/entities/entity-col-float.eta

@@ -1,6 +1,6 @@
 <% const {field} = it; %>
 
-@Column({ "type": "decimal"<% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
+@Column({ "type": "decimal", nullable: <%= Boolean(field.nullable) %><% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
 <% if (field.index ) {%>
 @Index()
 <% } %>

package/dist/lib/templates/entities/entity-col-integer.eta

@@ -1,6 +1,6 @@
 <% const {field} = it; %>
 
-@Column({ "type": "int"<% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
+@Column({ "type": "int", nullable: <%= Boolean(field.nullable) %><% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
 <% if (field.index ) {%>
 @Index()
 <% } %>

package/dist/lib/templates/entities/entity-col-money.eta

@@ -1,6 +1,6 @@
 <% const {field} = it; %>
 
-@Column({ "type": "money"<% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
+@Column({ "type": "money", nullable: <%= Boolean(field.nullable) %><% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
 <% if (field.index ) {%>
 @Index()
 <% } %>

package/dist/lib/templates/entities/entity-col-numeric.eta

@@ -1,6 +1,6 @@
 <% const {field} = it; %>
 
-@Column({ "type": "numeric", precision: <%= field.precision || 10 %>, scale: <%= field.scale || 2 %><% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
+@Column({ "type": "numeric", precision: <%= field.precision || 10 %>, scale: <%= field.scale || 2 %>, nullable: <%= Boolean(field.nullable) %><% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
 <% if (field.index ) {%>
 @Index()
 <% } %>

package/dist/lib/templates/entities/entity-col-real.eta

@@ -1,6 +1,6 @@
 <% const {field} = it; %>
 
-@Column({ "type": "real"<% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
+@Column({ "type": "real", nullable: <%= Boolean(field.nullable) %><% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
 <% if (field.index ) {%>
 @Index()
 <% } %>

package/dist/lib/templates/entities/entity-col-smallint.eta

@@ -1,6 +1,6 @@
 <% const {field} = it; %>
 
-@Column({ "type": "smallint"<% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
+@Column({ "type": "smallint", nullable: <%= Boolean(field.nullable) %><% if (field.default !== null) {%>, default:  <%= field.default %><% } %> })
 <% if (field.index ) {%>
 @Index()
 <% } %>

package/dist/lib/templates/go/utils/query.eta

@@ -222,19 +222,21 @@ func applyOperator(query *gorm.DB, field, op, value string, useOr bool) *gorm.DB
 		where = query.Or
 	}
 
+	cv := coerceValue(value)
+
 	switch op {
 	case "$eq":
-		return where(fmt.Sprintf("%s = ?", field), value)
+		return where(fmt.Sprintf("%s = ?", field), cv)
 	case "$ne":
-		return where(fmt.Sprintf("%s != ?", field), value)
+		return where(fmt.Sprintf("%s != ?", field), cv)
 	case "$gt":
-		return where(fmt.Sprintf("%s > ?", field), value)
+		return where(fmt.Sprintf("%s > ?", field), cv)
 	case "$gte":
-		return where(fmt.Sprintf("%s >= ?", field), value)
+		return where(fmt.Sprintf("%s >= ?", field), cv)
 	case "$lt":
-		return where(fmt.Sprintf("%s < ?", field), value)
+		return where(fmt.Sprintf("%s < ?", field), cv)
 	case "$lte":
-		return where(fmt.Sprintf("%s <= ?", field), value)
+		return where(fmt.Sprintf("%s <= ?", field), cv)
 	case "$starts":
 		return where(fmt.Sprintf("%s LIKE ?", field), value+"%")
 	case "$ends":
@@ -244,9 +246,9 @@ func applyOperator(query *gorm.DB, field, op, value string, useOr bool) *gorm.DB
 	case "$excl":
 		return where(fmt.Sprintf("%s NOT LIKE ?", field), "%"+value+"%")
 	case "$in":
-		return where(fmt.Sprintf("%s IN ?", field), splitValue(value))
+		return where(fmt.Sprintf("%s IN ?", field), coerceValues(splitValue(value)))
 	case "$notin":
-		return where(fmt.Sprintf("%s NOT IN ?", field), splitValue(value))
+		return where(fmt.Sprintf("%s NOT IN ?", field), coerceValues(splitValue(value)))
 	case "$isnull":
 		return where(fmt.Sprintf("%s IS NULL", field))
 	case "$notnull":
@@ -254,7 +256,7 @@ func applyOperator(query *gorm.DB, field, op, value string, useOr bool) *gorm.DB
 	case "$between":
 		vals := splitValue(value)
 		if len(vals) >= 2 {
-			return where(fmt.Sprintf("%s BETWEEN ? AND ?", field), vals[0], vals[1])
+			return where(fmt.Sprintf("%s BETWEEN ? AND ?", field), coerceValue(vals[0]), coerceValue(vals[1]))
 		}
 		return query
 	case "$eqL":
@@ -299,3 +301,29 @@ func splitValue(value string) []string {
 	}
 	return result
 }
+
+// coerceValue converts a string query parameter to a typed value.
+// Booleans and numbers are converted so the database driver sends the
+// correct wire type instead of a raw string.
+func coerceValue(value string) interface{} {
+	low := strings.ToLower(value)
+	if low == "true" || low == "false" || low == "yes" || low == "no" || low == "1" || low == "0" {
+		return low == "true" || low == "yes" || low == "1"
+	}
+	if v, err := strconv.ParseInt(value, 10, 64); err == nil {
+		return v
+	}
+	if v, err := strconv.ParseFloat(value, 64); err == nil {
+		return v
+	}
+	return value
+}
+
+// coerceValues applies coerceValue to each element in a slice.
+func coerceValues(values []string) []interface{} {
+	result := make([]interface{}, len(values))
+	for i, v := range values {
+		result[i] = coerceValue(v)
+	}
+	return result
+}

package/dist/lib/templates/python/utils/query.eta

@@ -6,7 +6,7 @@ import math
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Type, TypeVar
 
-from sqlalchemy import asc, desc, func, or_
+from sqlalchemy import Boolean, Date, DateTime, Float, Integer, Numeric, asc, desc, func, or_
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import selectinload
 from sqlalchemy.sql import Select, select
@@ -65,30 +65,58 @@ class PaginatedResult:
 # Operator registry
 # ---------------------------------------------------------------------------
 
+def _coerce_value(col: Any, value: str) -> Any:
+    """Coerce a string query param value to match the column's SQL type."""
+    try:
+        col_type = col.property.columns[0].type
+    except (AttributeError, IndexError):
+        return value
+
+    if isinstance(col_type, Boolean):
+        return value.lower() in ("true", "1", "yes")
+    if isinstance(col_type, (Integer,)):
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            return value
+    if isinstance(col_type, (Float, Numeric)):
+        try:
+            return float(value)
+        except (ValueError, TypeError):
+            return value
+    return value
+
+
+def _coerce_list(col: Any, values: List[str]) -> List[Any]:
+    """Coerce a list of string values to match the column's SQL type."""
+    return [_coerce_value(col, v) for v in values]
+
+
 def _apply_operator(model: Any, field_name: str, op: str, value: str) -> Any:
     """Return a SQLAlchemy filter expression for the given operator."""
     col = getattr(model, field_name, None)
     if col is None:
         return None
 
+    typed_value = _coerce_value(col, value)
     lower_col = func.lower(col)
 
     operators: Dict[str, Any] = {
-        "$eq": lambda: col == value,
-        "$ne": lambda: col != value,
-        "$gt": lambda: col > value,
-        "$gte": lambda: col >= value,
-        "$lt": lambda: col < value,
-        "$lte": lambda: col <= value,
+        "$eq": lambda: col == typed_value,
+        "$ne": lambda: col != typed_value,
+        "$gt": lambda: col > typed_value,
+        "$gte": lambda: col >= typed_value,
+        "$lt": lambda: col < typed_value,
+        "$lte": lambda: col <= typed_value,
         "$starts": lambda: col.like(f"{value}%"),
         "$ends": lambda: col.like(f"%{value}"),
         "$cont": lambda: col.like(f"%{value}%"),
         "$excl": lambda: ~col.like(f"%{value}%"),
-        "$in": lambda: col.in_(_split_value(value)),
-        "$notin": lambda: ~col.in_(_split_value(value)),
+        "$in": lambda: col.in_(_coerce_list(col, _split_value(value))),
+        "$notin": lambda: ~col.in_(_coerce_list(col, _split_value(value))),
         "$isnull": lambda: col.is_(None),
         "$notnull": lambda: col.isnot(None),
-        "$between": lambda: col.between(*_split_value(value)[:2]),
+        "$between": lambda: col.between(*_coerce_list(col, _split_value(value)[:2])),
         "$eqL": lambda: lower_col == value.lower(),
         "$neL": lambda: lower_col != value.lower(),
         "$startsL": lambda: lower_col.like(f"{value.lower()}%"),

package/dist/lib/utils/schema-convert.js

@@ -147,7 +147,7 @@ exports.serviceSchemaToApsorc = serviceSchemaToApsorc;
  */
 function sortKeys(value) {
     if (Array.isArray(value)) {
-        return value.map(sortKeys);
+        return value.map((item) => sortKeys(item));
     }
     if (value !== null && typeof value === "object") {
         const sorted = {};

package/dist/lib/utils/spinner.js

@@ -39,7 +39,8 @@ async function createSpinner(text) {
     const config = config_1.globalConfig.read();
     try {
         // Dynamic import to keep ora optional at startup
-        const ora = (await Promise.resolve().then(() => __importStar(require("ora")))).default;
+        const oraModule = await Promise.resolve().then(() => __importStar(require("ora")));
+        const ora = oraModule.default;
         const spinner = ora({
             text,
             color: config.noColor ? undefined : "cyan",

package/dist/lib/utils/template.js

@@ -6,7 +6,7 @@ const fs = tslib_1.__importStar(require("fs"));
 const path = tslib_1.__importStar(require("path"));
 const shelljs_1 = tslib_1.__importDefault(require("shelljs"));
 exports.TEMPLATE_REPOS = {
-    typescript: "https://github.com/apsoai/service-template.git",
+    typescript: "https://github.com/apsoai/service-template-ts.git",
     python: "https://github.com/apsoai/service-template-python.git",
     go: "https://github.com/apsoai/service-template-go.git",
 };

package/npm-shrinkwrap.json

@@ -1,13 +1,13 @@
 {
   "name": "@apso/cli",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@apso/cli",
-      "version": "0.14.0",
-      "license": "MIT",
+      "version": "0.15.1",
+      "license": "Apache-2.0",
       "dependencies": {
         "@electric-sql/pglite": "^0.2.17",
         "@modelcontextprotocol/sdk": "^1.29.0",
@@ -22,7 +22,8 @@
         "rc": "^1.2.8",
         "shelljs": "^0.8.5",
         "typeorm": "^0.3.20",
-        "typeorm-pglite": "^0.3.4"
+        "typeorm-pglite": "^0.3.4",
+        "zod": "^4.4.3"
       },
       "bin": {
         "apso": "bin/run"

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.14.0",
+  "version": "0.15.1",
   "commands": {
     "config": {
       "id": "config",
@@ -73,7 +73,7 @@
     },
     "dev": {
       "id": "dev",
-      "description": "Start the local development server using Docker Compose",
+      "description": "Start the local development server. Detects project language and database type from .apsorc and .env.",
       "strict": true,
       "pluginName": "@apso/cli",
       "pluginAlias": "@apso/cli",
@@ -81,22 +81,27 @@
       "aliases": [],
       "examples": [
         "$ apso dev",
-        "$ apso dev --build",
-        "$ apso dev --detach",
-        "$ apso dev --build --detach"
+        "$ apso dev --docker",
+        "$ apso dev --docker --build"
       ],
       "flags": {
+        "docker": {
+          "name": "docker",
+          "type": "boolean",
+          "description": "Use Docker Compose instead of the native dev stack",
+          "allowNo": false
+        },
         "detach": {
           "name": "detach",
           "type": "boolean",
           "char": "d",
-          "description": "Run containers in the background",
+          "description": "Run containers in the background (Docker mode only)",
           "allowNo": false
         },
         "build": {
           "name": "build",
           "type": "boolean",
-          "description": "Rebuild images before starting",
+          "description": "Rebuild images before starting (Docker mode only)",
           "allowNo": false
         }
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apso/cli",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "mcpName": "io.github.apsoai/apso",
   "description": "Apso CLI",
   "author": "Apso by Mavric - @mavric",
@@ -37,7 +37,8 @@
     "rc": "^1.2.8",
     "shelljs": "^0.8.5",
     "typeorm": "^0.3.20",
-    "typeorm-pglite": "^0.3.4"
+    "typeorm-pglite": "^0.3.4",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",