onflyt-cli 1.0.1-beta.2 → 1.0.1-beta.3

package/dist/lib/framework.js

@@ -0,0 +1,184 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { FRAMEWORKS as SHARED_FRAMEWORKS, getDefaultOutputDirectory, } from "./shared";
+export const FRAMEWORKS = SHARED_FRAMEWORKS;
+export const FRAMEWORK_LIST = Object.entries(SHARED_FRAMEWORKS).map(([id, config]) => ({
+    id,
+    name: config.label,
+    family: config.family,
+    isServer: config.isServer,
+}));
+export class FrameworkDetector {
+    cwd;
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+    }
+    detect() {
+        if (this.hasFile("next.config.js") ||
+            this.hasFile("next.config.mjs") ||
+            this.hasFile("next.config.ts")) {
+            return this.toFramework("nextjs");
+        }
+        if (this.hasFile("nuxt.config.ts") || this.hasFile("nuxt.config.js")) {
+            return this.toFramework("nuxt");
+        }
+        if (this.hasFile("package.json")) {
+            const pkg = this.readPackageJson();
+            if (!pkg)
+                return null;
+            if (pkg.dependencies?.next || pkg.devDependencies?.next) {
+                return this.toFramework("nextjs");
+            }
+            if (pkg.dependencies?.react || pkg.devDependencies?.react) {
+                if (pkg.dependencies?.remix)
+                    return this.toFramework("remix");
+                if (pkg.dependencies?.nuxt || pkg.devDependencies?.nuxt)
+                    return this.toFramework("nuxt");
+                if (pkg.dependencies?.svelte || pkg.devDependencies?.svelte)
+                    return this.toFramework("svelte");
+                if (pkg.dependencies?.angular || pkg.devDependencies?.angular)
+                    return this.toFramework("angular");
+                if (pkg.dependencies?.hono || pkg.devDependencies?.hono)
+                    return this.toFramework("hono");
+                if (pkg.dependencies?.nestjs || pkg.devDependencies?.nestjs)
+                    return this.toFramework("nestjs");
+                return this.toFramework("react");
+            }
+            if (pkg.dependencies?.vue || pkg.devDependencies?.vue) {
+                return this.toFramework("vue");
+            }
+            if (pkg.dependencies?.express || pkg.devDependencies?.express) {
+                return this.toFramework("express");
+            }
+            if (pkg.dependencies?.fastapi || pkg.devDependencies?.fastapi) {
+                return this.toFramework("fastapi");
+            }
+            if (pkg.dependencies?.django || pkg.devDependencies?.django) {
+                return this.toFramework("django");
+            }
+            if (pkg.dependencies?.flask || pkg.devDependencies?.flask) {
+                return this.toFramework("flask");
+            }
+            if (pkg.dependencies?.hono || pkg.devDependencies?.hono) {
+                return this.toFramework("hono");
+            }
+            if (pkg.dependencies?.nestjs || pkg.devDependencies?.nestjs) {
+                return this.toFramework("nestjs");
+            }
+            if (pkg.scripts?.dev || pkg.scripts?.start) {
+                return this.toFramework("node");
+            }
+        }
+        if (this.hasFile("requirements.txt") || this.hasFile("Pipfile")) {
+            const content = this.readFile("requirements.txt") || this.readFile("Pipfile") || "";
+            if (content.includes("fastapi"))
+                return this.toFramework("fastapi");
+            if (content.includes("django"))
+                return this.toFramework("django");
+            if (content.includes("flask"))
+                return this.toFramework("flask");
+            return this.toFramework("python");
+        }
+        if (this.hasFile("go.mod")) {
+            return this.toFramework("go");
+        }
+        if (this.hasFile("Cargo.toml")) {
+            return this.toFramework("rust");
+        }
+        if (this.hasFile("index.html")) {
+            return this.toFramework("static");
+        }
+        if (this.hasFile("Dockerfile")) {
+            return this.toFramework("docker");
+        }
+        return null;
+    }
+    detectOutputDirectory(frameworkId) {
+        const lowerId = frameworkId.toLowerCase();
+        if (this.hasFile("package.json")) {
+            const pkg = this.readPackageJson();
+            if (pkg) {
+                const scripts = pkg.scripts || {};
+                if (scripts.build) {
+                    if (lowerId === "nextjs") {
+                        if (this.hasFile(".next"))
+                            return ".next";
+                    }
+                    if (lowerId === "react" || lowerId === "vue" || lowerId === "vite") {
+                        if (this.hasFile("dist"))
+                            return "dist";
+                        if (this.hasFile("build"))
+                            return "build";
+                    }
+                    if (lowerId === "nuxt") {
+                        if (this.hasFile(".output"))
+                            return ".output";
+                    }
+                    if (lowerId === "svelte") {
+                        if (this.hasFile("build"))
+                            return "build";
+                        if (this.hasFile("dist"))
+                            return "dist";
+                    }
+                    if (lowerId === "astro") {
+                        if (this.hasFile("dist"))
+                            return "dist";
+                    }
+                }
+            }
+        }
+        return getDefaultOutputDirectory(lowerId) || null;
+    }
+    toFramework(id) {
+        const config = SHARED_FRAMEWORKS[id.toLowerCase()];
+        if (!config) {
+            return { id, name: id };
+        }
+        return {
+            id,
+            name: config.label,
+            buildCommand: config.defaults.buildCommand,
+            outputDirectory: config.defaults.outputDirectory,
+            installCommand: config.defaults.installCommand,
+            startCommand: config.defaults.startCommand,
+        };
+    }
+    hasFile(filename) {
+        return existsSync(join(this.cwd, filename));
+    }
+    readFile(filename) {
+        try {
+            const path = join(this.cwd, filename);
+            if (existsSync(path)) {
+                return readFileSync(path, "utf-8");
+            }
+        }
+        catch {
+            // ignore
+        }
+        return null;
+    }
+    readPackageJson() {
+        try {
+            const content = this.readFile("package.json");
+            if (content) {
+                return JSON.parse(content);
+            }
+        }
+        catch {
+            // ignore
+        }
+        return null;
+    }
+    getSuggestions() {
+        return Object.entries(SHARED_FRAMEWORKS).map(([id, config]) => ({
+            id,
+            name: config.label,
+            buildCommand: config.defaults.buildCommand,
+            outputDirectory: config.defaults.outputDirectory,
+            installCommand: config.defaults.installCommand,
+            startCommand: config.defaults.startCommand,
+        }));
+    }
+}
+export { getFramework } from "./shared";

package/dist/lib/git.d.ts

@@ -0,0 +1,25 @@
+export interface GitRemote {
+    name: string;
+    url: string;
+    type: "github" | "gitlab" | "other";
+}
+export interface GitInfo {
+    isGitRepo: boolean;
+    remotes: GitRemote[];
+    currentBranch: string;
+    rootDir: string;
+}
+export declare class GitDetector {
+    private cwd;
+    constructor(cwd?: string);
+    detect(): Promise<GitInfo>;
+    private isGitRepository;
+    private getRootDir;
+    private getCurrentBranch;
+    private getRemotes;
+    private detectRemoteType;
+    getBranches(): Promise<string[]>;
+    getRepoId(): Promise<number | null>;
+    static getProjectNameFromRepo(repoUrl: string): string;
+    static getOwnerFromRepo(repoUrl: string): string;
+}

package/dist/lib/git.js

@@ -0,0 +1,149 @@
+import { execSync } from "child_process";
+export class GitDetector {
+    cwd;
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+    }
+    async detect() {
+        try {
+            const isGitRepo = this.isGitRepository();
+            if (!isGitRepo) {
+                return {
+                    isGitRepo: false,
+                    remotes: [],
+                    currentBranch: "",
+                    rootDir: this.cwd,
+                };
+            }
+            const rootDir = this.getRootDir();
+            const remotes = this.getRemotes();
+            const currentBranch = this.getCurrentBranch();
+            return {
+                isGitRepo: true,
+                remotes,
+                currentBranch,
+                rootDir,
+            };
+        }
+        catch {
+            return {
+                isGitRepo: false,
+                remotes: [],
+                currentBranch: "",
+                rootDir: this.cwd,
+            };
+        }
+    }
+    isGitRepository() {
+        try {
+            execSync("git rev-parse --git-dir", {
+                cwd: this.cwd,
+                stdio: "ignore",
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getRootDir() {
+        try {
+            const root = execSync("git rev-parse --show-toplevel", {
+                cwd: this.cwd,
+                encoding: "utf-8",
+            }).trim();
+            return root;
+        }
+        catch {
+            return this.cwd;
+        }
+    }
+    getCurrentBranch() {
+        try {
+            const branch = execSync("git branch --show-current", {
+                cwd: this.cwd,
+                encoding: "utf-8",
+            }).trim();
+            return branch;
+        }
+        catch {
+            return "";
+        }
+    }
+    getRemotes() {
+        try {
+            const output = execSync("git remote -v", {
+                cwd: this.cwd,
+                encoding: "utf-8",
+            });
+            const remotes = [];
+            const lines = output.trim().split("\n");
+            for (const line of lines) {
+                const match = line.match(/^(\S+)\s+(\S+)\s+\((\w+)\)$/);
+                if (match) {
+                    const [, name, url] = match;
+                    const type = this.detectRemoteType(url);
+                    if (!remotes.find((r) => r.name === name)) {
+                        remotes.push({ name, url, type });
+                    }
+                }
+            }
+            return remotes;
+        }
+        catch {
+            return [];
+        }
+    }
+    detectRemoteType(url) {
+        if (url.includes("github.com"))
+            return "github";
+        if (url.includes("gitlab.com"))
+            return "gitlab";
+        return "other";
+    }
+    async getBranches() {
+        try {
+            const output = execSync("git branch -a", {
+                cwd: this.cwd,
+                encoding: "utf-8",
+            });
+            return output
+                .trim()
+                .split("\n")
+                .map((b) => b.replace(/^\*?\s*/, "").trim())
+                .filter((b) => (b && !b.startsWith("remotes/")) || b.startsWith("remotes/origin/"))
+                .map((b) => b.replace(/^remotes\/origin\//, ""));
+        }
+        catch {
+            return [];
+        }
+    }
+    async getRepoId() {
+        try {
+            const output = execSync("git remote get-url origin", {
+                cwd: this.cwd,
+                encoding: "utf-8",
+            }).trim();
+            const match = output.match(/git@github\.com:(\d+)\//);
+            if (match) {
+                return parseInt(match[1], 10);
+            }
+            const urlMatch = output.match(/github\.com\/[^\/]+\/([^\/\.]+)/);
+            if (urlMatch) {
+                return null;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    static getProjectNameFromRepo(repoUrl) {
+        const match = repoUrl.match(/\/([^\/]+?)(?:\.git)?$/);
+        return match ? match[1] : "";
+    }
+    static getOwnerFromRepo(repoUrl) {
+        const match = repoUrl.match(/github\.com\/([^\/]+)\//);
+        return match ? match[1] : "";
+    }
+}

package/dist/lib/scaffold.d.ts

@@ -0,0 +1,21 @@
+export interface ScaffoldProgress {
+    stage: "cloning" | "installing" | "cleaning" | "done";
+    message: string;
+    progress?: number;
+}
+export declare class Scaffold {
+    private cwd;
+    private onProgress?;
+    private tempDir;
+    constructor(cwd: string, onProgress?: (p: ScaffoldProgress) => void);
+    report(progress: ScaffoldProgress): void;
+    cloneTemplate(repoUrl: string, branch?: string): Promise<void>;
+    installDependencies(packageManager: string): Promise<void>;
+    moveFilesToProject(): Promise<void>;
+    cleanup(): void;
+    scaffold(repoUrl: string, packageManager: string): Promise<void>;
+}
+export declare function isGitInstalled(): boolean;
+export declare function isNodeInstalled(): boolean;
+export declare function initGitRepo(cwd: string, remoteUrl?: string): void;
+export declare function generateProjectId(): string;

package/dist/lib/scaffold.js

@@ -0,0 +1,190 @@
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, cpSync, rmSync, } from "fs";
+import { join } from "path";
+export class Scaffold {
+    cwd;
+    onProgress;
+    tempDir;
+    constructor(cwd, onProgress) {
+        this.cwd = cwd;
+        this.onProgress = onProgress;
+        this.tempDir = join("/tmp", `onflyt-scaffold-${Date.now()}`);
+    }
+    report(progress) {
+        if (this.onProgress) {
+            this.onProgress(progress);
+        }
+    }
+    async cloneTemplate(repoUrl, branch = "main") {
+        this.report({
+            stage: "cloning",
+            message: "Cloning template...",
+            progress: 0,
+        });
+        try {
+            mkdirSync(this.tempDir, { recursive: true });
+            const gitUrl = repoUrl.endsWith(".git") ? repoUrl : `${repoUrl}.git`;
+            execSync(`git clone --depth 1 --branch ${branch} ${gitUrl} "${this.tempDir}"`, { stdio: "pipe" });
+            this.report({
+                stage: "cloning",
+                message: "Template cloned",
+                progress: 100,
+            });
+        }
+        catch (error) {
+            this.cleanup();
+            throw new Error(`Failed to clone template: ${error.message}`);
+        }
+    }
+    async installDependencies(packageManager) {
+        if (!packageManager || packageManager === "none") {
+            return;
+        }
+        this.report({
+            stage: "installing",
+            message: `Installing dependencies with ${packageManager}...`,
+            progress: 0,
+        });
+        try {
+            let installCmd = "";
+            switch (packageManager) {
+                case "npm":
+                    installCmd = "npm install";
+                    break;
+                case "yarn":
+                    installCmd = "yarn install";
+                    break;
+                case "pnpm":
+                    installCmd = "pnpm install";
+                    break;
+                case "pip":
+                    installCmd = "pip install -r requirements.txt";
+                    break;
+                case "poetry":
+                    installCmd = "poetry install";
+                    break;
+                default:
+                    return;
+            }
+            execSync(installCmd, {
+                cwd: this.tempDir,
+                stdio: "inherit",
+            });
+            this.report({
+                stage: "installing",
+                message: "Dependencies installed",
+                progress: 100,
+            });
+        }
+        catch (error) {
+            console.error(`Warning: Failed to install dependencies: ${error.message}`);
+            console.error("You may need to run the install command manually.");
+        }
+    }
+    async moveFilesToProject() {
+        this.report({
+            stage: "cleaning",
+            message: "Preparing project files...",
+            progress: 50,
+        });
+        try {
+            const items = [
+                "package.json",
+                "requirements.txt",
+                "src",
+                "app",
+                "lib",
+                "components",
+                "pages",
+                "routes",
+                "api",
+                "main.py",
+                "index.js",
+                "server.js",
+                "app.js",
+                "main.go",
+                "Cargo.toml",
+                "go.mod",
+                "README.md",
+                "next.config.js",
+                "next.config.mjs",
+                "vite.config.ts",
+                "vite.config.js",
+                "nuxt.config.ts",
+                "pyproject.toml",
+            ];
+            for (const item of items) {
+                const srcPath = join(this.tempDir, item);
+                const destPath = join(this.cwd, item);
+                if (existsSync(srcPath) && !existsSync(destPath)) {
+                    cpSync(srcPath, destPath, { recursive: true });
+                }
+            }
+            this.report({ stage: "cleaning", message: "Files copied", progress: 90 });
+        }
+        catch (error) {
+            console.error(`Warning: Failed to copy some files: ${error.message}`);
+        }
+    }
+    cleanup() {
+        try {
+            if (existsSync(this.tempDir)) {
+                rmSync(this.tempDir, { recursive: true, force: true });
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+    async scaffold(repoUrl, packageManager) {
+        try {
+            await this.cloneTemplate(repoUrl);
+            await this.installDependencies(packageManager);
+            await this.moveFilesToProject();
+            this.cleanup();
+            this.report({
+                stage: "done",
+                message: "Project scaffolded",
+                progress: 100,
+            });
+        }
+        catch (error) {
+            this.cleanup();
+            throw error;
+        }
+    }
+}
+export function isGitInstalled() {
+    try {
+        execSync("git --version", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isNodeInstalled() {
+    try {
+        execSync("node --version", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function initGitRepo(cwd, remoteUrl) {
+    try {
+        execSync("git init", { cwd, stdio: "pipe" });
+        if (remoteUrl) {
+            execSync(`git remote add origin ${remoteUrl}`, { cwd, stdio: "pipe" });
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to init git: ${error.message}`);
+    }
+}
+export function generateProjectId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `${timestamp}-${random}`;
+}

package/dist/shared/frameworks/registry.d.ts

@@ -0,0 +1,21 @@
+export type FrameworkFamily = "node" | "nixpacks";
+export type DeploymentType = "static" | "container";
+export interface FrameworkDefaults {
+    buildCommand?: string;
+    installCommand?: string;
+    outputDirectory?: string;
+    startCommand?: string;
+}
+export interface FrameworkConfig {
+    label: string;
+    family: FrameworkFamily;
+    deploymentType: DeploymentType;
+    defaults: FrameworkDefaults;
+    isServer: boolean;
+}
+export declare const FRAMEWORKS: Record<string, FrameworkConfig>;
+export declare function getFramework(id: string): FrameworkConfig | undefined;
+export declare function getDefaultBuildCommand(frameworkId: string): string | undefined;
+export declare function getDefaultOutputDirectory(frameworkId: string): string | undefined;
+export declare function getDefaultStartCommand(frameworkId: string): string | undefined;
+export declare function getInstallCommand(frameworkId: string, packageManager: string): string;