alpic 0.0.0-dev.added1b → 0.0.0-dev.adefca3

package/dist/lib/project.d.ts

@@ -1,67 +1,65 @@
-import type { RouterOutput } from "@alpic-ai/api";
+import type { RouterOutput, Runtime } from "@alpic-ai/api";
 import type { ProjectConfig } from "../types.js";
-export declare function resolveDeployDir(raw: string | undefined): string;
-export declare function confirmDeployWithExistingConfig(existingConfig: ProjectConfig): Promise<boolean | null>;
-export declare function selectEnvironmentFromList(environments: RouterOutput["projects"]["get"]["v1"]["environments"]): Promise<{
-    id: string;
-    name: string;
-    sourceBranch: string | null;
-    mcpServerUrl: string;
-    createdAt: Date;
-    projectId: string;
-    latestDeployment: {
-        id: string;
-        status: "ongoing" | "deployed" | "failed" | "canceled";
-        sourceCommitId: string | null;
-        sourceCommitMessage: string | null;
-        completedAt: Date | null;
-    } | null;
-} | null>;
-export declare function confirmDeployDirectory(deployDir: string): Promise<boolean>;
-export declare function confirmLinkExisting(): Promise<boolean>;
-export declare function confirmLinkToAnotherProject(): Promise<boolean>;
-export declare function selectProjectFromList(projects: RouterOutput["projects"]["list"]["v1"]): Promise<{
-    id: string;
-    name: string;
-    teamId: string;
-    sourceRepository: string | null;
-    runtime: "python3.13" | "python3.14" | "node22" | "node24";
-    transport: "stdio" | "sse" | "streamablehttp" | null;
-    rootDirectory: string | null;
-    buildCommand: string | null;
-    buildOutputDir: string | null;
-    installCommand: string | null;
-    startCommand: string | null;
-    createdAt: Date;
-    productionEnvironment: {
-        id: string;
-        name: string;
-        mcpServerUrl: string;
-        latestDeployment: {
-            id: string;
-            status: "ongoing" | "deployed" | "failed" | "canceled";
-            sourceCommitId: string | null;
-            sourceCommitMessage: string | null;
-            completedAt: Date | null;
-        } | null;
-    } | null;
-    environments: {
+import { BaseWorkflow } from "./base-workflow.js";
+export type ProjectFlags = {
+    yes?: boolean;
+    projectName?: string;
+    runtime?: Runtime;
+    rootDir?: string;
+};
+export declare class ProjectWorkflow extends BaseWorkflow<ProjectFlags> {
+    selectEnvironmentFromList(environments: RouterOutput["projects"]["get"]["v1"]["environments"]): Promise<(typeof environments)[number] | null>;
+    selectProjectFromList(projects: RouterOutput["projects"]["list"]["v1"]): Promise<{
         id: string;
         name: string;
-        sourceBranch: string | null;
-        mcpServerUrl: string;
+        teamId: string;
+        sourceRepository: string | null;
+        runtime: "python3.13" | "python3.14" | "node22" | "node24";
+        transport: "stdio" | "sse" | "streamablehttp" | null;
+        rootDirectory: string | null;
+        buildCommand: string | null;
+        buildOutputDir: string | null;
+        installCommand: string | null;
+        startCommand: string | null;
         createdAt: Date;
-        projectId: string;
-        latestDeployment: {
+        productionEnvironment: {
             id: string;
-            status: "ongoing" | "deployed" | "failed" | "canceled";
-            sourceCommitId: string | null;
-            sourceCommitMessage: string | null;
-            completedAt: Date | null;
+            name: string;
+            mcpServerUrl: string;
+            latestDeployment: {
+                id: string;
+                status: "ongoing" | "deployed" | "failed" | "canceled";
+                sourceCommitId: string | null;
+                sourceCommitMessage: string | null;
+                completedAt: Date | null;
+            } | null;
         } | null;
-    }[];
-} | null>;
-export declare function promptRootDirectory(deployDir: string): Promise<string | null | undefined>;
-export declare function resolveProjectForDeploy(deployDir: string): Promise<(ProjectConfig & {
-    environmentId: string;
-}) | null>;
+        environments: {
+            id: string;
+            name: string;
+            sourceBranch: string | null;
+            mcpServerUrl: string;
+            createdAt: Date;
+            projectId: string;
+            latestDeployment: {
+                id: string;
+                status: "ongoing" | "deployed" | "failed" | "canceled";
+                sourceCommitId: string | null;
+                sourceCommitMessage: string | null;
+                completedAt: Date | null;
+            } | null;
+        }[];
+    } | null>;
+    promptRootDirectory(deployDir: string): Promise<string | null>;
+    private detectRuntime;
+    confirmDeployWithExistingConfig(existingConfig: ProjectConfig): Promise<boolean | null>;
+    confirmDeployDirectory(deployDir: string): Promise<boolean>;
+    confirmLinkExisting(): Promise<boolean>;
+    confirmLinkToAnotherProject(): Promise<boolean>;
+    resolveProjectForDeploy(deployDir: string): Promise<(ProjectConfig & {
+        environmentId: string;
+    }) | null>;
+    private resolveEnvironmentForProject;
+    private runCreateProjectFlow;
+    private runLinkingFlow;
+}

package/dist/lib/project.js

@@ -3,283 +3,281 @@ import chalk from "chalk";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 import { api } from "../api.js";
+import { BaseWorkflow } from "./base-workflow.js";
 import { config } from "./config.js";
-export function resolveDeployDir(raw) {
-    const dir = resolve((raw ?? "").trim() || process.cwd());
-    if (!existsSync(dir)) {
-        throw new Error(`Path does not exist: ${dir}`);
-    }
-    if (!statSync(dir).isDirectory()) {
-        throw new Error(`Path is not a directory: ${dir}`);
-    }
-    return dir;
-}
-export async function confirmDeployWithExistingConfig(existingConfig) {
-    const envLabel = existingConfig.environmentName ? ` to environment "${existingConfig.environmentName}"` : "";
-    const confirm = await p.confirm({
-        message: chalk.bold(`Deploy project "${existingConfig.projectName}"${envLabel}?`),
-        initialValue: true,
-    });
-    if (p.isCancel(confirm))
-        return null;
-    return confirm === true;
-}
-export async function selectEnvironmentFromList(environments) {
-    if (environments.length === 0) {
-        return null;
-    }
-    const choice = await p.select({
-        message: chalk.bold("Choose an environment to deploy to"),
-        options: environments.map((env) => ({
-            value: env.id,
-            label: env.sourceBranch ? `${env.name} (${env.sourceBranch})` : env.name,
-        })),
-    });
-    if (p.isCancel(choice))
-        return null;
-    const environment = environments.find((e) => e.id === choice);
-    return environment ?? null;
-}
-export async function confirmDeployDirectory(deployDir) {
-    const confirm = await p.confirm({
-        message: chalk.bold(`Deploy the directory? `) + chalk.cyan(deployDir),
-        initialValue: true,
-    });
-    if (p.isCancel(confirm))
-        return false;
-    return confirm === true;
-}
-export async function confirmLinkExisting() {
-    const link = await p.confirm({
-        message: chalk.bold("Link to existing project?"),
-        initialValue: true,
-    });
-    if (p.isCancel(link))
-        return false;
-    return link === true;
-}
-export async function confirmLinkToAnotherProject() {
-    const link = await p.confirm({
-        message: chalk.bold("Link to another project?"),
-        initialValue: true,
-    });
-    if (p.isCancel(link))
-        return false;
-    return link === true;
-}
-export async function selectProjectFromList(projects) {
-    if (projects.length === 0) {
-        return null;
-    }
-    const choice = await p.select({
-        message: chalk.bold("Choose a project"),
-        options: projects.map((proj) => ({ value: proj.id, label: proj.name })),
-    });
-    if (p.isCancel(choice))
-        return null;
-    const project = projects.find((proj) => proj.id === choice);
-    return project ?? null;
-}
-export async function promptRootDirectory(deployDir) {
-    while (true) {
-        const rootDir = await p.text({
-            message: chalk.bold("Root directory"),
-            placeholder: ".",
-            initialValue: ".",
-            validate: (value) => {
-                if (value != null && value.length > 512)
-                    return "Path must be at most 512 characters.";
-                return undefined;
-            },
-        });
-        if (p.isCancel(rootDir))
+export class ProjectWorkflow extends BaseWorkflow {
+    async selectEnvironmentFromList(environments) {
+        if (environments.length === 0) {
             return null;
-        const trimmed = rootDir.trim();
-        if (trimmed === "" || trimmed === ".")
-            return undefined;
-        const resolved = resolve(deployDir, trimmed);
-        if (!existsSync(resolved)) {
-            p.log.error(`Path does not exist: ${resolved}`);
-            continue;
-        }
-        if (!statSync(resolved).isDirectory()) {
-            p.log.error(`Path is not a directory: ${resolved}`);
-            continue;
         }
-        return trimmed;
+        const choice = await p.select({
+            message: chalk.bold("Choose an environment to deploy to"),
+            options: environments.map((env) => ({
+                value: env.id,
+                label: env.sourceBranch ? `${env.name} (${env.sourceBranch})` : env.name,
+            })),
+        });
+        if (p.isCancel(choice))
+            return null;
+        const environment = environments.find((e) => e.id === choice);
+        return environment ?? null;
     }
-}
-async function resolveEnvironmentForProject(projectId) {
-    const project = await api.projects.get.v1({ projectId });
-    const environments = project.environments ?? [];
-    if (environments.length === 0) {
-        throw new Error("No environments found for this project.");
+    async selectProjectFromList(projects) {
+        if (projects.length === 0) {
+            return null;
+        }
+        const choice = await p.select({
+            message: chalk.bold("Choose a project"),
+            options: projects.map((proj) => ({ value: proj.id, label: proj.name })),
+        });
+        if (p.isCancel(choice))
+            return null;
+        const project = projects.find((proj) => proj.id === choice);
+        return project ?? null;
     }
-    const environment = await selectEnvironmentFromList(environments);
-    if (!environment)
-        return null;
-    return { environmentId: environment.id, environmentName: environment.name };
-}
-export async function resolveProjectForDeploy(deployDir) {
-    const ok = await confirmDeployDirectory(deployDir);
-    if (!ok)
-        return null;
-    const existingConfig = config.load(deployDir);
-    if (existingConfig) {
-        let confirm;
+    async promptRootDirectory(deployDir) {
         while (true) {
-            confirm = await confirmDeployWithExistingConfig(existingConfig);
-            if (confirm === null)
+            const rootDir = this.flags.rootDir ??
+                (await p.text({
+                    message: chalk.bold("Root directory"),
+                    placeholder: ".",
+                    initialValue: ".",
+                    validate: (value) => {
+                        if (value != null && value.length > 512)
+                            return "Path must be at most 512 characters.";
+                        return undefined;
+                    },
+                }));
+            if (p.isCancel(rootDir))
                 return null;
-            if (confirm)
-                break;
-            const linkAnother = await confirmLinkToAnotherProject();
-            if (p.isCancel(linkAnother))
+            const trimmed = rootDir.trim();
+            if (trimmed === "" || trimmed === ".")
                 return null;
-            if (linkAnother) {
-                const linkExisting = await confirmLinkExisting();
-                if (!linkExisting) {
-                    return runCreateProjectFlow(deployDir);
-                }
-                return runLinkingFlow(deployDir);
+            const resolved = resolve(deployDir, trimmed);
+            if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
+                p.log.error(`Path is not a directory: ${resolved}`);
+                if (this.flags.rootDir)
+                    return null;
+                continue;
             }
+            return trimmed;
         }
-        if (existingConfig.environmentId) {
-            return {
-                projectId: existingConfig.projectId,
-                teamId: existingConfig.teamId,
-                projectName: existingConfig.projectName,
-                environmentId: existingConfig.environmentId,
-                environmentName: existingConfig.environmentName,
-            };
+    }
+    detectRuntime(dir) {
+        const has = (file) => existsSync(resolve(dir, file));
+        const read = (file) => {
+            try {
+                return readFileSync(resolve(dir, file), "utf8");
+            }
+            catch {
+                return "";
+            }
+        };
+        if (has("pyproject.toml") || has("requirements.txt") || has("setup.py") || has(".python-version")) {
+            return "python3.13";
         }
-        const env = await resolveEnvironmentForProject(existingConfig.projectId);
-        if (!env)
+        if (has("package.json")) {
+            const nvmrc = has(".nvmrc") ? (read(".nvmrc").trim().split(/\s/)[0] ?? "") : "";
+            const major = nvmrc.replace(/^v/i, "").match(/^(\d+)/)?.[1];
+            if (major === "22")
+                return "node22";
+            return "node24";
+        }
+        return null;
+    }
+    async confirmDeployWithExistingConfig(existingConfig) {
+        const envLabel = existingConfig.environmentName ? ` to environment "${existingConfig.environmentName}"` : "";
+        const confirmed = await this.confirm({
+            message: chalk.bold(`Deploy project "${existingConfig.projectName}"${envLabel}?`),
+            initialValue: true,
+        });
+        if (p.isCancel(confirmed))
             return null;
-        const updatedConfig = {
-            ...existingConfig,
-            environmentId: env.environmentId,
-            environmentName: env.environmentName,
-        };
-        config.save(updatedConfig, deployDir);
-        p.note(`Environment "${env.environmentName}" will be used for future deploys.`, undefined, {
-            format: (line) => line,
+        return confirmed === true;
+    }
+    async confirmDeployDirectory(deployDir) {
+        const confirmed = await this.confirm({
+            message: chalk.bold(`Deploy the directory? `) + chalk.cyan(deployDir),
+            initialValue: true,
         });
-        return updatedConfig;
+        if (p.isCancel(confirmed))
+            return false;
+        return confirmed === true;
     }
-    const linkExisting = await confirmLinkExisting();
-    if (!linkExisting) {
-        return runCreateProjectFlow(deployDir);
+    async confirmLinkExisting() {
+        const link = await this.confirm({
+            message: chalk.bold("Link to existing project?"),
+            initialValue: true,
+        }, false);
+        if (p.isCancel(link))
+            return false;
+        return link === true;
     }
-    return runLinkingFlow(deployDir);
-}
-async function runCreateProjectFlow(deployDir) {
-    const name = await p.text({
-        message: chalk.bold("Project name"),
-        placeholder: "my-app",
-        validate: (value) => {
-            if (!value?.trim())
-                return "Project name is required.";
-            if (value.length > 100)
-                return "Project name must be at most 100 characters.";
-            return undefined;
-        },
-    });
-    if (p.isCancel(name))
-        return null;
-    const detectedRuntime = detectRuntime(deployDir);
-    const runtime = await p.select({
-        message: chalk.bold("Runtime"),
-        options: [
-            { value: "node24", label: "Node.js 24" },
-            { value: "node22", label: "Node.js 22" },
-            { value: "python3.14", label: "Python 3.14" },
-            { value: "python3.13", label: "Python 3.13" },
-        ],
-        initialValue: detectedRuntime ?? "node24",
-    });
-    if (p.isCancel(runtime))
-        return null;
-    const rootDirectory = await promptRootDirectory(deployDir);
-    const spin = p.spinner();
-    spin.start("Creating project...");
-    try {
-        const projectInput = {
-            name: name.trim(),
-            runtime,
-        };
-        if (rootDirectory) {
-            projectInput.rootDirectory = rootDirectory;
+    async confirmLinkToAnotherProject() {
+        const link = await this.confirm({
+            message: chalk.bold("Link to another project?"),
+            initialValue: true,
+        }, false);
+        if (p.isCancel(link))
+            return false;
+        return link === true;
+    }
+    async resolveProjectForDeploy(deployDir) {
+        const ok = await this.confirmDeployDirectory(deployDir);
+        if (!ok)
+            return null;
+        const existingConfig = config.load(deployDir);
+        if (existingConfig) {
+            let confirmed;
+            while (true) {
+                confirmed = await this.confirmDeployWithExistingConfig(existingConfig);
+                if (confirmed === null)
+                    return null;
+                if (confirmed)
+                    break;
+                const linkAnother = await this.confirmLinkToAnotherProject();
+                if (p.isCancel(linkAnother))
+                    return null;
+                if (linkAnother) {
+                    const linkExisting = await this.confirmLinkExisting();
+                    if (!linkExisting) {
+                        return this.runCreateProjectFlow(deployDir);
+                    }
+                    return this.runLinkingFlow(deployDir);
+                }
+            }
+            if (existingConfig.environmentId) {
+                return {
+                    projectId: existingConfig.projectId,
+                    teamId: existingConfig.teamId,
+                    projectName: existingConfig.projectName,
+                    environmentId: existingConfig.environmentId,
+                    environmentName: existingConfig.environmentName,
+                };
+            }
+            const env = await this.resolveEnvironmentForProject(existingConfig.projectId);
+            if (!env)
+                return null;
+            const updatedConfig = {
+                ...existingConfig,
+                environmentId: env.environmentId,
+                environmentName: env.environmentName,
+            };
+            config.save(updatedConfig, deployDir);
+            p.note(`Environment "${env.environmentName}" will be used for future deploys.`, undefined, {
+                format: (line) => line,
+            });
+            return updatedConfig;
         }
-        const created = await api.projects.create.v1(projectInput);
-        spin.stop("Project created.");
-        const productionEnv = created.productionEnvironment;
-        if (!productionEnv) {
-            throw new Error("Project was created but has no Production environment.");
+        const linkExisting = await this.confirmLinkExisting();
+        if (!linkExisting) {
+            return this.runCreateProjectFlow(deployDir);
         }
-        const newConfig = {
-            projectId: created.id,
-            teamId: created.teamId,
-            projectName: created.name,
-            environmentId: productionEnv.id,
-            environmentName: productionEnv.name,
-        };
-        config.save(newConfig, deployDir);
-        return newConfig;
+        return this.runLinkingFlow(deployDir);
     }
-    catch (error) {
-        spin.stop();
-        throw error;
-    }
-}
-async function runLinkingFlow(deployDir) {
-    const projects = await api.projects.list.v1();
-    if (projects.length === 0) {
-        throw new Error("No projects found. Create a project in the Alpic dashboard first.");
-    }
-    const project = await selectProjectFromList(projects);
-    if (!project)
-        return null;
-    const environments = project.environments ?? [];
-    if (environments.length === 0) {
-        throw new Error("No environments found for this project.");
+    async resolveEnvironmentForProject(projectId) {
+        const project = await api.projects.get.v1({ projectId });
+        const environments = project.environments ?? [];
+        if (environments.length === 0) {
+            throw new Error("No environments found for this project.");
+        }
+        const environment = await this.selectEnvironmentFromList(environments);
+        if (!environment)
+            return null;
+        return { environmentId: environment.id, environmentName: environment.name };
     }
-    const environment = await selectEnvironmentFromList(environments);
-    if (!environment)
-        return null;
-    const newConfig = {
-        projectId: project.id,
-        teamId: project.teamId,
-        projectName: project.name,
-        environmentId: environment.id,
-        environmentName: environment.name,
-    };
-    config.save(newConfig, deployDir);
-    p.note(`Linked to project "${project.name}", environment "${environment.name}".`, undefined, {
-        format: (line) => line,
-    });
-    return newConfig;
-}
-function detectRuntime(dir) {
-    const has = (file) => existsSync(resolve(dir, file));
-    const read = (file) => {
+    async runCreateProjectFlow(deployDir) {
+        const name = this.flags.projectName ??
+            (await p.text({
+                message: chalk.bold("Project name"),
+                placeholder: "my-app",
+                validate: (value) => {
+                    if (!value?.trim())
+                        return "Project name is required.";
+                    if (value.length > 100)
+                        return "Project name must be at most 100 characters.";
+                    return undefined;
+                },
+            }));
+        if (p.isCancel(name)) {
+            p.cancel("Project name is required.");
+            return null;
+        }
+        const detectedRuntime = this.detectRuntime(deployDir);
+        const defaultRuntime = detectedRuntime ?? "node24";
+        const runtime = this.isNonInteractive() && this.flags.runtime
+            ? defaultRuntime
+            : await p.select({
+                message: chalk.bold("Runtime"),
+                options: [
+                    { value: "node24", label: "Node.js 24" },
+                    { value: "node22", label: "Node.js 22" },
+                    { value: "python3.14", label: "Python 3.14" },
+                    { value: "python3.13", label: "Python 3.13" },
+                ],
+                initialValue: defaultRuntime,
+            });
+        if (p.isCancel(runtime)) {
+            p.cancel("Runtime is required.");
+            return null;
+        }
+        const rootDirectory = await this.promptRootDirectory(deployDir);
+        const spin = p.spinner();
+        spin.start("Creating project...");
         try {
-            return readFileSync(resolve(dir, file), "utf8");
+            const projectInput = {
+                name,
+                runtime,
+            };
+            projectInput.rootDirectory = rootDirectory ?? undefined;
+            const created = await api.projects.create.v1(projectInput);
+            spin.stop("Project created.");
+            const productionEnv = created.productionEnvironment;
+            if (!productionEnv) {
+                throw new Error("Project was created but has no Production environment.");
+            }
+            const newConfig = {
+                projectId: created.id,
+                teamId: created.teamId,
+                projectName: created.name,
+                environmentId: productionEnv.id,
+                environmentName: productionEnv.name,
+            };
+            config.save(newConfig, deployDir);
+            return newConfig;
         }
-        catch {
-            return "";
+        catch (error) {
+            spin.stop();
+            throw error;
         }
-    };
-    if (has("pyproject.toml") || has("requirements.txt") || has("setup.py") || has(".python-version")) {
-        return "python3.13";
     }
-    if (has("package.json")) {
-        const nvmrc = has(".nvmrc") ? (read(".nvmrc").trim().split(/\s/)[0] ?? "") : "";
-        const major = nvmrc.replace(/^v/i, "").match(/^(\d+)/)?.[1];
-        if (major === "22")
-            return "node22";
-        return "node24";
+    async runLinkingFlow(deployDir) {
+        const projects = await api.projects.list.v1();
+        if (projects.length === 0) {
+            throw new Error("No projects found. Create a project in the Alpic dashboard first.");
+        }
+        const project = await this.selectProjectFromList(projects);
+        if (!project)
+            return null;
+        const environments = project.environments ?? [];
+        if (environments.length === 0) {
+            throw new Error("No environments found for this project.");
+        }
+        const environment = await this.selectEnvironmentFromList(environments);
+        if (!environment)
+            return null;
+        const newConfig = {
+            projectId: project.id,
+            teamId: project.teamId,
+            projectName: project.name,
+            environmentId: environment.id,
+            environmentName: environment.name,
+        };
+        config.save(newConfig, deployDir);
+        p.note(`Linked to project "${project.name}", environment "${environment.name}".`, undefined, {
+            format: (line) => line,
+        });
+        return newConfig;
     }
-    return null;
 }
 //# sourceMappingURL=project.js.map