@unifiedcommerce/cli 0.0.1

package/dist/commands/deploy.d.ts

@@ -0,0 +1,13 @@
+export declare const deployCommand: import("citty").CommandDef<{
+    target: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+    prod: {
+        type: "boolean";
+        default: false;
+        description: string;
+    };
+}>;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/commands/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/commands/deploy.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa;;;;;;;;;;;EA4CxB,CAAC"}

package/dist/commands/deploy.js

@@ -0,0 +1,45 @@
+import { spawn } from "node:child_process";
+import { defineCommand } from "citty";
+import consola from "consola";
+export const deployCommand = defineCommand({
+    meta: {
+        name: "deploy",
+        description: "Deploy UnifiedCommerce app to a target environment.",
+    },
+    args: {
+        target: {
+            type: "string",
+            required: true,
+            description: "Deployment target. Supported: vercel",
+        },
+        prod: {
+            type: "boolean",
+            default: false,
+            description: "Deploy production build",
+        },
+    },
+    async run({ args }) {
+        const target = String(args.target).toLowerCase();
+        if (target !== "vercel") {
+            throw new Error(`Unsupported deploy target: ${target}. Currently supported: vercel.`);
+        }
+        const command = process.platform === "win32" ? "npx.cmd" : "npx";
+        const deployArgs = ["vercel", "deploy"];
+        if (args.prod)
+            deployArgs.push("--prod");
+        consola.info(`Running deploy for target=${target} (${deployArgs.join(" ")})`);
+        await new Promise((resolvePromise, rejectPromise) => {
+            const proc = spawn(command, deployArgs, {
+                stdio: "inherit",
+                shell: false,
+            });
+            proc.on("exit", (code) => {
+                if (code === 0)
+                    resolvePromise();
+                else
+                    rejectPromise(new Error(`Deploy command failed with code ${code}`));
+            });
+            proc.on("error", rejectPromise);
+        });
+    },
+});

package/dist/commands/dev.d.ts

@@ -0,0 +1,7 @@
+export declare const devCommand: import("citty").CommandDef<{
+    port: {
+        type: "string";
+        default: string;
+    };
+}>;
+//# sourceMappingURL=dev.d.ts.map

package/dist/commands/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/commands/dev.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU;;;;;EAgCrB,CAAC"}

package/dist/commands/dev.js

@@ -0,0 +1,32 @@
+import { spawn } from "node:child_process";
+import { defineCommand } from "citty";
+import consola from "consola";
+export const devCommand = defineCommand({
+    meta: {
+        name: "dev",
+        description: "Run local dev server with file watching",
+    },
+    args: {
+        port: {
+            type: "string",
+            default: "3000",
+        },
+    },
+    async run({ args }) {
+        const port = String(args.port);
+        consola.info(`Starting dev server on port ${port}`);
+        const proc = spawn(process.platform === "win32" ? "npx.cmd" : "npx", ["tsx", "watch", "src/dev-server.ts", "--port", port], {
+            stdio: "inherit",
+            shell: false,
+        });
+        await new Promise((resolvePromise, rejectPromise) => {
+            proc.on("exit", (code) => {
+                if (code === 0)
+                    resolvePromise();
+                else
+                    rejectPromise(new Error(`dev exited with code ${code}`));
+            });
+            proc.on("error", rejectPromise);
+        });
+    },
+});

package/dist/commands/generate-migration.d.ts

@@ -0,0 +1,2 @@
+export declare const generateMigrationCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+//# sourceMappingURL=generate-migration.d.ts.map

package/dist/commands/generate-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-migration.d.ts","sourceRoot":"","sources":["../../src/commands/generate-migration.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,wBAAwB,qDAmBnC,CAAC"}

package/dist/commands/generate-migration.js

@@ -0,0 +1,20 @@
+import { spawn } from "node:child_process";
+import { defineCommand } from "citty";
+export const generateMigrationCommand = defineCommand({
+    meta: {
+        name: "generate migration",
+        description: "Generate Drizzle migration",
+    },
+    async run() {
+        await new Promise((resolvePromise, rejectPromise) => {
+            const proc = spawn(process.platform === "win32" ? "npx.cmd" : "npx", ["drizzle-kit", "generate"], { stdio: "inherit" });
+            proc.on("exit", (code) => {
+                if (code === 0)
+                    resolvePromise();
+                else
+                    rejectPromise(new Error(`drizzle-kit generate failed with code ${code}`));
+            });
+            proc.on("error", rejectPromise);
+        });
+    },
+});

package/dist/commands/import.d.ts

@@ -0,0 +1,45 @@
+export declare const importCommand: import("citty").CommandDef<{
+    source: {
+        type: "string";
+        required: true;
+        description: string;
+    };
+    input: {
+        type: "string";
+        description: string;
+    };
+    targetUrl: {
+        type: "string";
+        default: string;
+        description: string;
+    };
+    authToken: {
+        type: "string";
+        description: string;
+    };
+    apiKey: {
+        type: "string";
+        description: string;
+    };
+    storeUrl: {
+        type: "string";
+        description: string;
+    };
+    consumerKey: {
+        type: "string";
+        description: string;
+    };
+    consumerSecret: {
+        type: "string";
+        description: string;
+    };
+    mapping: {
+        type: "string";
+        description: string;
+    };
+    entityType: {
+        type: "string";
+        default: string;
+    };
+}>;
+//# sourceMappingURL=import.d.ts.map

package/dist/commands/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/commands/import.ts"],"names":[],"mappings":"AAwJA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2KxB,CAAC"}

package/dist/commands/import.js

@@ -0,0 +1,237 @@
+import { readFile } from "node:fs/promises";
+import { extname, resolve } from "node:path";
+import { defineCommand } from "citty";
+import consola from "consola";
+// @ts-ignore — missing type declarations
+import { importFlat } from "@unifiedcommerce/import-flat";
+// @ts-ignore — missing type declarations
+import { importShopifyCatalog } from "@unifiedcommerce/import-shopify";
+// @ts-ignore — missing type declarations
+import { importWooCommerceCatalog } from "@unifiedcommerce/import-woocommerce";
+function toBaseUrl(raw) {
+    return (raw ?? "http://localhost:3000").replace(/\/$/, "");
+}
+function toHeaders(token) {
+    if (!token)
+        return {};
+    return { authorization: `Bearer ${token}` };
+}
+async function requestJson(baseUrl, path, method, body, token) {
+    const response = await fetch(`${baseUrl}${path}`, {
+        method,
+        headers: {
+            "content-type": "application/json",
+            ...toHeaders(token),
+        },
+        body: JSON.stringify(body),
+    });
+    const payload = (await response.json().catch(() => ({})));
+    if (!response.ok) {
+        const message = payload.error?.message ?? `HTTP ${response.status}`;
+        throw new Error(`Request failed for ${method} ${path}: ${message}`);
+    }
+    if (payload.data === undefined) {
+        throw new Error(`Expected data payload for ${method} ${path}.`);
+    }
+    return payload.data;
+}
+function createRestImportTarget(baseUrl, token) {
+    return {
+        async createEntity(input) {
+            return requestJson(baseUrl, "/api/catalog/entities", "POST", input, token);
+        },
+        async createOptionType(input) {
+            return requestJson(baseUrl, `/api/catalog/entities/${input.entityId}/options`, "POST", input, token);
+        },
+        async createOptionValue(input) {
+            return requestJson(baseUrl, `/api/catalog/options/${input.optionTypeId}/values`, "POST", input, token);
+        },
+        async createVariant(input) {
+            return requestJson(baseUrl, `/api/catalog/entities/${input.entityId}/variants`, "POST", input, token);
+        },
+        async uploadMedia(input) {
+            const form = new FormData();
+            form.set("file", new File([input.data], input.filename, {
+                type: input.contentType,
+            }));
+            if (input.alt)
+                form.set("alt", input.alt);
+            const response = await fetch(`${baseUrl}/api/media/upload`, {
+                method: "POST",
+                headers: {
+                    ...toHeaders(token),
+                },
+                body: form,
+            });
+            const payload = (await response.json().catch(() => ({})));
+            if (!response.ok || !payload.data) {
+                throw new Error(payload.error?.message ?? `Media upload failed (${response.status}).`);
+            }
+            return payload.data;
+        },
+        async attachMedia(input) {
+            await requestJson(baseUrl, "/api/media/attach", "POST", input, token);
+        },
+    };
+}
+async function loadJsonInput(path) {
+    const absolute = resolve(process.cwd(), path);
+    const raw = await readFile(absolute, "utf8");
+    return JSON.parse(raw);
+}
+export const importCommand = defineCommand({
+    meta: {
+        name: "import",
+        description: "Import catalog data from Shopify, WooCommerce, or flat CSV/JSON into UnifiedCommerce.",
+    },
+    args: {
+        source: {
+            type: "string",
+            required: true,
+            description: "shopify | woocommerce | flat",
+        },
+        input: {
+            type: "string",
+            description: "Path to input JSON/CSV for offline imports",
+        },
+        targetUrl: {
+            type: "string",
+            default: "http://localhost:3000",
+            description: "UnifiedCommerce API base URL",
+        },
+        authToken: {
+            type: "string",
+            description: "Optional bearer token for target API",
+        },
+        apiKey: {
+            type: "string",
+            description: "Shopify admin API key/token",
+        },
+        storeUrl: {
+            type: "string",
+            description: "Shopify or WooCommerce store URL",
+        },
+        consumerKey: {
+            type: "string",
+            description: "WooCommerce consumer key",
+        },
+        consumerSecret: {
+            type: "string",
+            description: "WooCommerce consumer secret",
+        },
+        mapping: {
+            type: "string",
+            description: "Path to flat-import mapping JSON (required for source=flat)",
+        },
+        entityType: {
+            type: "string",
+            default: "product",
+        },
+    },
+    async run({ args }) {
+        const source = String(args.source).toLowerCase();
+        const baseUrl = toBaseUrl(args.targetUrl ? String(args.targetUrl) : undefined);
+        const token = args.authToken ? String(args.authToken) : undefined;
+        const target = createRestImportTarget(baseUrl, token);
+        if (source === "shopify") {
+            let products;
+            let customers;
+            if (args.input) {
+                const parsed = await loadJsonInput(String(args.input));
+                if (Array.isArray(parsed)) {
+                    products = parsed;
+                }
+                else if (parsed && typeof parsed === "object") {
+                    products = parsed.products;
+                    customers = parsed.customers;
+                }
+            }
+            const imported = await importShopifyCatalog({
+                target,
+                ...(args.storeUrl ? { storeUrl: String(args.storeUrl) } : {}),
+                ...(args.apiKey ? { apiKey: String(args.apiKey) } : {}),
+                entityType: String(args.entityType),
+                ...(Array.isArray(products) ? { products: products } : {}),
+                ...(Array.isArray(customers) ? { customers: customers } : {}),
+            });
+            if (!imported.ok) {
+                throw new Error(imported.error.message);
+            }
+            consola.success(`Shopify import completed: ${imported.value.entitiesImported} entities, ${imported.value.variantsImported} variants, ${imported.value.mediaImported} media.`);
+            if (imported.value.customersImported > 0) {
+                consola.info(`Imported customers: ${imported.value.customersImported}`);
+            }
+            if (imported.value.errors.length > 0) {
+                consola.warn(`Import completed with ${imported.value.errors.length} warnings.`);
+            }
+            return;
+        }
+        if (source === "woocommerce") {
+            let products;
+            let customers;
+            if (args.input) {
+                const parsed = await loadJsonInput(String(args.input));
+                if (Array.isArray(parsed)) {
+                    products = parsed;
+                }
+                else if (parsed && typeof parsed === "object") {
+                    products = parsed.products;
+                    customers = parsed.customers;
+                }
+            }
+            const imported = await importWooCommerceCatalog({
+                target,
+                ...(args.storeUrl ? { storeUrl: String(args.storeUrl) } : {}),
+                ...(args.consumerKey ? { consumerKey: String(args.consumerKey) } : {}),
+                ...(args.consumerSecret ? { consumerSecret: String(args.consumerSecret) } : {}),
+                entityType: String(args.entityType),
+                ...(Array.isArray(products) ? { products: products } : {}),
+                ...(Array.isArray(customers) ? { customers: customers } : {}),
+            });
+            if (!imported.ok) {
+                throw new Error(imported.error.message);
+            }
+            consola.success(`WooCommerce import completed: ${imported.value.entitiesImported} entities, ${imported.value.variantsImported} variants, ${imported.value.mediaImported} media.`);
+            if (imported.value.customersImported > 0) {
+                consola.info(`Imported customers: ${imported.value.customersImported}`);
+            }
+            if (imported.value.errors.length > 0) {
+                consola.warn(`Import completed with ${imported.value.errors.length} warnings.`);
+            }
+            return;
+        }
+        if (source === "flat") {
+            if (!args.mapping) {
+                throw new Error("--mapping is required for source=flat");
+            }
+            const mappingParsed = await loadJsonInput(String(args.mapping));
+            if (!mappingParsed || typeof mappingParsed !== "object") {
+                throw new Error("Flat import mapping file must be a JSON object.");
+            }
+            if (!args.input) {
+                throw new Error("--input is required for source=flat");
+            }
+            const inputPath = resolve(process.cwd(), String(args.input));
+            const raw = await readFile(inputPath, "utf8");
+            const extension = extname(inputPath).toLowerCase();
+            const imported = await importFlat({
+                mapping: mappingParsed,
+                target: {
+                    async createEntity(input) {
+                        return target.createEntity(input);
+                    },
+                },
+                ...(extension === ".csv" ? { csv: raw } : { json: raw }),
+            });
+            if (!imported.ok) {
+                throw new Error(imported.error.message);
+            }
+            consola.success(`Flat import completed: ${imported.value.imported} entities imported.`);
+            if (imported.value.failed > 0) {
+                consola.warn(`Failed rows: ${imported.value.failed}`);
+            }
+            return;
+        }
+        throw new Error(`Unsupported source: ${source}. Expected shopify, woocommerce, or flat.`);
+    },
+});

package/dist/commands/init.d.ts

@@ -0,0 +1,12 @@
+export declare const initCommand: import("citty").CommandDef<{
+    projectName: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    template: {
+        type: "string";
+        default: string;
+    };
+}>;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,WAAW;;;;;;;;;;EA+CtB,CAAC"}

package/dist/commands/init.js

@@ -0,0 +1,52 @@
+import { join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { defineCommand } from "citty";
+import consola from "consola";
+import { downloadTemplate } from "giget";
+import { copyDir, readJson, writeJson } from "../utils";
+const currentDir = fileURLToPath(new URL(".", import.meta.url));
+export const initCommand = defineCommand({
+    meta: {
+        name: "init",
+        description: "Scaffold a UnifiedCommerce project",
+    },
+    args: {
+        projectName: {
+            type: "positional",
+            description: "Project directory name",
+            required: true,
+        },
+        template: {
+            type: "string",
+            default: "starter",
+        },
+    },
+    async run({ args }) {
+        const projectName = String(args.projectName);
+        const destination = resolve(process.cwd(), projectName);
+        if (existsSync(destination)) {
+            throw new Error(`Directory ${destination} already exists.`);
+        }
+        const localTemplatePath = resolve(currentDir, "../../templates", String(args.template));
+        if (existsSync(localTemplatePath)) {
+            await copyDir(localTemplatePath, destination);
+        }
+        else {
+            await downloadTemplate(`gh:unifiedcommerce/templates/${String(args.template)}`, {
+                dir: destination,
+            });
+        }
+        const packageJsonPath = join(destination, "package.json");
+        if (existsSync(packageJsonPath)) {
+            const pkg = await readJson(packageJsonPath);
+            pkg.name = projectName;
+            await writeJson(packageJsonPath, pkg);
+        }
+        consola.success(`Project created at ${destination}`);
+        consola.info(`Next steps:`);
+        consola.info(`  cd ${projectName}`);
+        consola.info(`  bun install`);
+        consola.info(`  bun run dev`);
+    },
+});

package/dist/commands/migrate.d.ts

@@ -0,0 +1,2 @@
+export declare const migrateCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/commands/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../src/commands/migrate.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,qDAmBzB,CAAC"}

package/dist/commands/migrate.js

@@ -0,0 +1,20 @@
+import { spawn } from "node:child_process";
+import { defineCommand } from "citty";
+export const migrateCommand = defineCommand({
+    meta: {
+        name: "migrate",
+        description: "Apply Drizzle migrations",
+    },
+    async run() {
+        await new Promise((resolvePromise, rejectPromise) => {
+            const proc = spawn(process.platform === "win32" ? "npx.cmd" : "npx", ["drizzle-kit", "migrate"], { stdio: "inherit" });
+            proc.on("exit", (code) => {
+                if (code === 0)
+                    resolvePromise();
+                else
+                    rejectPromise(new Error(`drizzle-kit migrate failed with code ${code}`));
+            });
+            proc.on("error", rejectPromise);
+        });
+    },
+});

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+import { initCommand } from "./commands/init";
+import { devCommand } from "./commands/dev";
+import { generateMigrationCommand } from "./commands/generate-migration";
+import { migrateCommand } from "./commands/migrate";
+import { deployCommand } from "./commands/deploy";
+import { importCommand } from "./commands/import";
+const main = defineCommand({
+    meta: {
+        name: "@unifiedcommerce/cli",
+        version: "0.0.1",
+        description: "UnifiedCommerce Engine CLI",
+    },
+    subCommands: {
+        init: initCommand,
+        dev: devCommand,
+        migrate: migrateCommand,
+        deploy: deployCommand,
+        import: importCommand,
+        generate: defineCommand({
+            subCommands: {
+                migration: generateMigrationCommand,
+            },
+        }),
+    },
+});
+await runMain(main);