@apso/cli 0.13.0 → 0.15.0

package/dist/commands/dev.d.ts

@@ -3,13 +3,65 @@ 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;
     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,246 @@ 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 = [];
+    }
     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
+        const cleanup = () => {
+            for (const child of this.children) {
+                child.kill("SIGTERM");
+            }
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", 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", cleanup);
+            process.removeListener("SIGTERM", 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 {
+            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 +251,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 +258,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/doctor.d.ts

@@ -0,0 +1,10 @@
+import BaseCommand from "../lib/base-command";
+export default class Doctor extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        report: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/doctor.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const core_1 = require("@oclif/core");
+const inquirer = tslib_1.__importStar(require("inquirer"));
+const base_command_1 = tslib_1.__importDefault(require("../lib/base-command"));
+const apsorc_parser_1 = require("../lib/apsorc-parser");
+const runner_1 = require("../lib/doctor/runner");
+class Doctor extends base_command_1.default {
+    async run() {
+        const { flags } = await this.parse(Doctor);
+        // Find and parse .apsorc
+        const configPath = (0, apsorc_parser_1.findConfigPath)();
+        if (!configPath) {
+            this.error("No .apsorc file found in the current directory or parent directories.");
+        }
+        let parsed;
+        try {
+            parsed = (0, apsorc_parser_1.parseApsorc)();
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.error(`Failed to parse .apsorc: ${msg}`);
+        }
+        const projectRoot = path.dirname(configPath);
+        const language = parsed.language || "typescript";
+        const ctx = {
+            entities: parsed.entities,
+            relationshipMap: parsed.relationshipMap,
+            rootFolder: parsed.rootFolder || "src",
+            language,
+            projectRoot,
+        };
+        if (!flags.json) {
+            this.log("Running diagnostics...");
+        }
+        const findings = await (0, runner_1.runDiagnostics)(ctx);
+        // Output
+        if (flags.json) {
+            this.log(JSON.stringify(findings, null, 2));
+        }
+        else {
+            this.log("");
+            this.log((0, runner_1.formatFindings)(findings));
+            const errors = findings.filter((f) => f.severity === "error").length;
+            const warnings = findings.filter((f) => f.severity === "warning").length;
+            this.log(`${findings.length} finding(s): ${errors} error(s), ${warnings} warning(s)`);
+        }
+        // Report flow
+        if (flags.report) {
+            const actionable = findings.filter((f) => f.severity === "error" || f.severity === "warning");
+            if (actionable.length === 0) {
+                this.log("No errors or warnings to report.");
+                return;
+            }
+            if (!(0, runner_1.isGhAvailable)()) {
+                this.error("GitHub CLI (gh) is not installed or not authenticated.\n" +
+                    "Install: https://cli.github.com\n" +
+                    "Authenticate: gh auth login");
+            }
+            // Dedupe check
+            const firstError = actionable.find((f) => f.severity === "error") || actionable[0];
+            const searchTitle = firstError.message.slice(0, 100);
+            const existing = (0, runner_1.searchExistingIssues)(searchTitle);
+            if (existing.length > 0) {
+                this.log("");
+                this.log("Potentially related open issues:");
+                for (const issue of existing) {
+                    this.log(`  #${issue.number}: ${issue.title}`);
+                    this.log(`    ${issue.url}`);
+                }
+                this.log("");
+                const { proceed } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "proceed",
+                        message: "File a new issue anyway?",
+                        default: false,
+                    },
+                ]);
+                if (!proceed) {
+                    this.log("Aborted.");
+                    return;
+                }
+            }
+            // Confirm before filing
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `File a GitHub issue with ${actionable.length} finding(s) against apsoai/cli?`,
+                    default: true,
+                },
+            ]);
+            if (!confirm) {
+                this.log("Aborted.");
+                return;
+            }
+            try {
+                const url = (0, runner_1.fileGitHubIssue)(findings, ctx);
+                this.log(`Issue filed: ${url}`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                this.error(`Failed to file issue: ${msg}`);
+            }
+        }
+    }
+}
+Doctor.description = "Run diagnostic checks on generated code and optionally file a GitHub issue with findings";
+Doctor.examples = [
+    `$ apso doctor`,
+    `$ apso doctor --json`,
+    `$ apso doctor --report`,
+];
+Doctor.flags = {
+    report: core_1.Flags.boolean({
+        description: "File a GitHub issue with diagnostic findings (requires gh CLI)",
+        default: false,
+    }),
+    json: core_1.Flags.boolean({
+        description: "Output findings as JSON instead of human-readable text",
+        default: false,
+    }),
+};
+exports.default = Doctor;

package/dist/commands/init.js

@@ -55,7 +55,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([
             {
@@ -170,7 +170,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([
                 {