@atmyapp/cli 0.0.7 → 0.0.8

package/dist/cli/commands/generate.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function generateCommand(): Command;

package/dist/cli/commands/generate.js

@@ -0,0 +1,119 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommand = generateCommand;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const logger_1 = require("../logger");
+const http_1 = require("../utils/http");
+const DEFAULT_BRANCH = "main";
+function generateCommand() {
+    return new commander_1.Command("generate")
+        .description("Generate a placeholder file in project storage")
+        .requiredOption("--path <path>", "POSIX project-relative path to generate")
+        .option("-t, --token <token>", "Authentication token override")
+        .option("-u, --url <url>", "Project base URL override")
+        .option("-p, --project-id <id>", "Project identifier override")
+        .option("--branch <name>", "Branch to target", DEFAULT_BRANCH)
+        .option("--save <file>", "Save generated content to a local file path")
+        .option("--json", "Print raw JSON response")
+        .option("--warnings-as-error", "Treat validation warnings as errors")
+        .option("--verbose", "Enable verbose logging")
+        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const logger = new logger_1.Logger(Boolean(options.verbose));
+        try {
+            const session = (0, http_1.resolveSession)({
+                token: options.token,
+                projectId: options.projectId,
+                url: options.url,
+            });
+            const targetPath = normalizePlaceholderPath(options.path);
+            const endpoint = buildGenerateEndpoint(session);
+            const url = (0, http_1.projectUrl)(session, endpoint, {
+                branch: (_a = options.branch) !== null && _a !== void 0 ? _a : DEFAULT_BRANCH,
+            });
+            const fetcher = (0, http_1.createAmaFetch)(session);
+            const { data, error } = yield fetcher(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ path: targetPath }),
+            });
+            if (error) {
+                const errorMessage = typeof error === "string"
+                    ? error
+                    : error instanceof Error
+                        ? error.message
+                        : (_b = error.message) !== null && _b !== void 0 ? _b : (error.status
+                            ? `HTTP ${error.status}`
+                            : "Unknown error");
+                throw new Error(`Request failed: ${errorMessage}`);
+            }
+            if (!data) {
+                throw new Error("No response received from the server.");
+            }
+            if (!data.success || !data.data) {
+                throw new Error(data.error || "Placeholder generation failed.");
+            }
+            const result = data.data;
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+            }
+            else {
+                logger.success(`Generated placeholder for ${result.path}.`);
+                if (result.warnings && result.warnings.length > 0) {
+                    logger.warn(`Warnings (${result.warnings.length}):\n${result.warnings
+                        .map((warning) => `  • ${warning}`)
+                        .join("\n")}`);
+                }
+            }
+            if (options.save) {
+                yield persistContent(options.save, result.content, logger);
+            }
+            if (options.warningsAsError &&
+                result.warnings &&
+                result.warnings.length > 0) {
+                throw new Error("Generation returned warnings treated as errors.");
+            }
+            logger.success("Placeholder generation completed.");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error(`Generation failed: ${message}`);
+            process.exit(1);
+        }
+    }));
+}
+function normalizePlaceholderPath(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        throw new Error("Path is required and cannot be empty.");
+    }
+    return trimmed.replace(/\\/g, "/");
+}
+function buildGenerateEndpoint(session) {
+    return `v0/projects/${encodeURIComponent(session.projectId)}/storage/ghost/placeholders`;
+}
+function persistContent(destination, content, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const absolutePath = path_1.default.resolve(process.cwd(), destination);
+        const directory = path_1.default.dirname(absolutePath);
+        yield fs_1.promises.mkdir(directory, { recursive: true });
+        yield fs_1.promises.writeFile(absolutePath, content, "utf8");
+        logger.success(`Saved generated content to ${absolutePath}.`);
+    });
+}

package/dist/cli/commands/migrate.js

@@ -31,16 +31,16 @@ function migrateCommand() {
         const startTime = Date.now();
         const logger = new utils_1.Logger(options.verbose);
         try {
-            logger.info("🚀 Starting migration process");
+            logger.info("Starting migration process.");
             logger.verbose_log(`Options: ${JSON.stringify(options)}`);
             if (options.parallel) {
-                logger.info("⚡ Parallel processing enabled");
+                logger.info("Parallel processing enabled.");
                 if (options.maxWorkers) {
-                    logger.info(`👥 Using ${options.maxWorkers} worker threads`);
+                    logger.info(`Using ${options.maxWorkers} worker threads.`);
                 }
             }
             else {
-                logger.info("🔄 Using sequential processing");
+                logger.info("Using sequential processing.");
             }
             const config = (0, utils_1.getConfig)();
             const patterns = config.include || ["**/*.ts", "**/*.tsx"];
@@ -49,23 +49,23 @@ function migrateCommand() {
             let processingResult;
             if (options.parallel !== false) {
                 // Use optimized parallel processing pipeline
-                logger.info("🚀 Using optimized parallel processing pipeline");
+                logger.info("Using optimized parallel processing pipeline.");
                 processingResult = yield (0, parallel_schema_processor_1.optimizedMigrationPipeline)(patterns, options.tsconfig, options.continueOnError, logger, options.maxWorkers);
             }
             else {
                 // Fallback to original sequential processing
-                logger.info("🔄 Using original sequential processing");
+                logger.info("Using original sequential processing.");
                 const files = yield (0, utils_1.scanFiles)(patterns, logger);
-                logger.info(`📚 Found ${files.length} files to process`);
+                logger.info(`Found ${files.length} files to process.`);
                 const project = (0, utils_1.createProject)(files, options.tsconfig, logger);
                 processingResult = (0, utils_1.processFiles)(project.getSourceFiles(), options.tsconfig, options.continueOnError, logger);
             }
             const { contents, errors, successCount, failureCount } = processingResult;
             // Report processing results
             const processingTime = ((Date.now() - startTime) / 1000).toFixed(2);
-            logger.success(`✅ Successfully processed ${successCount} AMA contents in ${processingTime}s`);
+            logger.success(`Successfully processed ${successCount} AMA contents in ${processingTime}s.`);
             if (failureCount > 0) {
-                logger.warn(`⚠️ Failed to process ${failureCount} items`);
+                logger.warn(`Failed to process ${failureCount} items.`);
                 if (options.verbose && errors.length > 0) {
                     logger.info("Errors encountered:");
                     errors.forEach((err) => logger.error(`  ${err}`));
@@ -77,14 +77,14 @@ function migrateCommand() {
             }
             // Generate and save output
             const outputStartTime = Date.now();
-            logger.info("🔧 Generating output definitions...");
+            logger.info("Generating output definitions...");
             const output = (0, utils_1.generateOutput)(contents, config, logger);
             const outputTime = ((Date.now() - outputStartTime) / 1000).toFixed(2);
             logger.verbose_log(`Output generation took ${outputTime}s`);
             (0, utils_1.saveOutputToFile)(output, logger);
             // Upload definitions unless dry-run is enabled
             if (!options.dryRun) {
-                logger.info("📤 Uploading definitions to AtMyApp platform");
+                logger.info("Uploading definitions to AtMyApp platform.");
                 const uploadStartTime = Date.now();
                 const uploadSuccess = yield (0, utils_1.uploadDefinitions)(output, config, logger);
                 const uploadTime = ((Date.now() - uploadStartTime) / 1000).toFixed(2);
@@ -95,13 +95,13 @@ function migrateCommand() {
                 }
             }
             else {
-                logger.info("🏁 Dry run mode enabled. Skipping upload to server.");
+                logger.info("Dry run mode enabled. Skipping upload to server.");
             }
             const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
-            logger.success(`🎉 Migration completed successfully in ${totalTime}s`);
+            logger.success(`Migration completed successfully in ${totalTime}s.`);
             // Performance summary
             if (options.verbose) {
-                logger.info("📊 Performance Summary:");
+                logger.info("Performance summary:");
                 logger.info(`  Total time: ${totalTime}s`);
                 logger.info(`  Processing time: ${processingTime}s`);
                 logger.info(`  Files processed: ${successCount}`);
@@ -114,7 +114,7 @@ function migrateCommand() {
         catch (error) {
             const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
             const message = error instanceof Error ? error.message : "Unknown error";
-            logger.error(`💥 Fatal error after ${totalTime}s: ${message}`, error);
+            logger.error(`Fatal error after ${totalTime}s: ${message}`, error);
             process.exit(1);
         }
     }));

package/dist/cli/commands/upload.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function uploadCommand(): Command;

package/dist/cli/commands/upload.js

@@ -0,0 +1,334 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadCommand = uploadCommand;
+const commander_1 = require("commander");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const logger_1 = require("../logger");
+const http_1 = require("../utils/http");
+const DEFAULT_BRANCH = "main";
+const DEFAULT_IGNORE_PATTERNS = ["**/.git/**", "**/.ama/**"];
+function uploadCommand() {
+    return new commander_1.Command("upload")
+        .description("Upload files to project storage")
+        .argument("[inputs...]")
+        .option("-t, --token <token>", "Authentication token override")
+        .option("-u, --url <url>", "Project base URL override")
+        .option("-p, --project-id <id>", "Project identifier override")
+        .option("-b, --base-path <path>", "Base remote path (relative to project root)")
+        .option("--branch <name>", "Branch to write to", DEFAULT_BRANCH)
+        .option("--environment-name <name>", "Environment name for scoped writes")
+        .option("--commit <message>", "Commit message recorded with the upload")
+        .option("--delete <path>", "Remote file path to delete (repeatable)", collectValues, [])
+        .option("--no-stream", "Disable streaming progress output (enabled by default)")
+        .option("--verbose", "Enable verbose logging")
+        .action((inputPatterns, options) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const logger = new logger_1.Logger(Boolean(options.verbose));
+        try {
+            const session = (0, http_1.resolveSession)({
+                token: options.token,
+                projectId: options.projectId,
+                url: options.url,
+            });
+            const basePath = normalizeBasePath(options.basePath);
+            const streamEnabled = options.stream !== false;
+            const files = yield prepareFiles(inputPatterns, basePath, logger);
+            const filesToDelete = normalizeDeletionPaths((_a = options.delete) !== null && _a !== void 0 ? _a : [], basePath, logger);
+            if (files.length === 0 && filesToDelete.length === 0) {
+                throw new Error("Nothing to upload. Provide file inputs or --delete paths to process.");
+            }
+            const body = {
+                files,
+            };
+            if (filesToDelete.length > 0) {
+                body.filesToDelete = filesToDelete;
+            }
+            if (options.commit) {
+                body.commitMessage = options.commit;
+            }
+            const query = {
+                branch: (_b = options.branch) !== null && _b !== void 0 ? _b : DEFAULT_BRANCH,
+            };
+            if (options.environmentName) {
+                query.environment_name = options.environmentName;
+            }
+            if (streamEnabled) {
+                query.stream = true;
+                yield performStreamingUpload(session, basePath, body, query, logger);
+            }
+            else {
+                yield performStandardUpload(session, basePath, body, query, logger);
+            }
+            logger.success("Upload completed successfully.");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error(`Upload failed: ${message}`);
+            process.exit(1);
+        }
+    }));
+}
+function collectValues(value, previous) {
+    previous.push(value);
+    return previous;
+}
+function normalizeBasePath(basePath) {
+    if (!basePath) {
+        return undefined;
+    }
+    const trimmed = basePath.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const normalized = toPosix(trimmed)
+        .replace(/^\.\/?/, "")
+        .replace(/\/+$/, "");
+    return normalized || undefined;
+}
+function toPosix(value) {
+    return value.replace(/\\/g, "/");
+}
+function prepareFiles(patterns, basePath, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!patterns || patterns.length === 0) {
+            return [];
+        }
+        const resolvedPaths = new Set();
+        for (const pattern of patterns) {
+            const expanded = yield expandInput(pattern);
+            if (expanded.length === 0) {
+                logger.warn(`No files matched pattern '${pattern}'.`);
+            }
+            for (const filePath of expanded) {
+                resolvedPaths.add(path_1.default.resolve(filePath));
+            }
+        }
+        const sortedPaths = Array.from(resolvedPaths).sort();
+        const files = [];
+        for (const absolutePath of sortedPaths) {
+            const buffer = yield fs_1.promises.readFile(absolutePath);
+            const relativePath = path_1.default.relative(process.cwd(), absolutePath) ||
+                path_1.default.basename(absolutePath);
+            const posixPath = toPosix(relativePath);
+            const remotePath = computeRemotePath(posixPath, basePath, logger);
+            logger.verbose_log(`Preparing file '${absolutePath}' as remote path '${remotePath}'.`);
+            files.push({
+                path: remotePath,
+                content: buffer.toString("base64"),
+            });
+        }
+        return files;
+    });
+}
+function expandInput(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cwd = process.cwd();
+        const absoluteCandidate = path_1.default.resolve(cwd, input);
+        try {
+            const stats = yield fs_1.promises.stat(absoluteCandidate);
+            if (stats.isDirectory()) {
+                const entries = yield (0, fast_glob_1.default)("**/*", {
+                    cwd: absoluteCandidate,
+                    dot: true,
+                    onlyFiles: true,
+                    followSymbolicLinks: false,
+                    ignore: DEFAULT_IGNORE_PATTERNS,
+                });
+                return entries.map((entry) => path_1.default.resolve(absoluteCandidate, entry));
+            }
+            if (stats.isFile()) {
+                return [absoluteCandidate];
+            }
+        }
+        catch (error) {
+            // Treat as glob when path resolution fails
+        }
+        const normalizedPattern = toPosix(input);
+        const matches = yield (0, fast_glob_1.default)(normalizedPattern, {
+            cwd,
+            dot: true,
+            onlyFiles: true,
+            followSymbolicLinks: false,
+            ignore: DEFAULT_IGNORE_PATTERNS,
+            unique: true,
+        });
+        return matches.map((match) => path_1.default.resolve(cwd, match));
+    });
+}
+function computeRemotePath(posixPath, basePath, logger) {
+    const cleaned = posixPath.replace(/^\.\//, "");
+    if (!basePath) {
+        return cleaned;
+    }
+    const relativeToBase = path_1.default.posix.relative(basePath, cleaned);
+    if (relativeToBase.startsWith("..")) {
+        logger.warn(`File '${cleaned}' is outside the base path '${basePath}'. Using absolute path.`);
+        return cleaned;
+    }
+    const normalized = relativeToBase.replace(/^\.\//, "");
+    const finalSegment = normalized || path_1.default.posix.basename(cleaned);
+    return `./${finalSegment}`;
+}
+function normalizeDeletionPaths(values, basePath, logger) {
+    if (!values || values.length === 0) {
+        return [];
+    }
+    const result = [];
+    for (const original of values) {
+        const trimmed = original.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const posix = toPosix(trimmed);
+        if (posix.startsWith("./")) {
+            result.push(`./${posix.replace(/^\.\/+/, "")}`);
+            continue;
+        }
+        if (posix.startsWith("/")) {
+            result.push(posix.replace(/^\/+/, ""));
+            continue;
+        }
+        result.push(computeRemotePath(posix, basePath, logger));
+    }
+    return result;
+}
+function buildUploadEndpoint(session, basePath) {
+    const projectSegment = `v0/projects/${encodeURIComponent(session.projectId)}/storage/f`;
+    if (!basePath) {
+        return projectSegment;
+    }
+    const encodedBase = (0, http_1.encodePathSegment)(basePath);
+    return `${projectSegment}/${encodedBase}`;
+}
+function performStreamingUpload(session, basePath, body, query, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const endpoint = buildUploadEndpoint(session, basePath);
+        const url = (0, http_1.projectUrl)(session, endpoint, {
+            branch: query.branch,
+            environment_name: query.environment_name,
+            stream: true,
+        });
+        const summary = {
+            updated: new Set(),
+            deleted: new Set(),
+            errors: new Map(),
+            hadErrorEvent: false,
+        };
+        yield (0, http_1.streamSse)({
+            url,
+            fetchInit: {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${session.token}`,
+                },
+                body: JSON.stringify(body),
+            },
+            onEvent: (event) => __awaiter(this, void 0, void 0, function* () {
+                if (event.data === "[DONE]") {
+                    return;
+                }
+                const payload = event.parsed;
+                if (!payload) {
+                    logger.verbose_log(`SSE: ${event.data}`);
+                    return;
+                }
+                if (payload.message) {
+                    logger.info(payload.message);
+                }
+                if (payload.updated) {
+                    payload.updated.forEach((item) => summary.updated.add(item));
+                }
+                if (payload.deleted) {
+                    payload.deleted.forEach((item) => summary.deleted.add(item));
+                }
+                if (payload.errors) {
+                    Object.entries(payload.errors).forEach(([key, value]) => {
+                        summary.errors.set(key, value);
+                        logger.error(`Error processing '${key}': ${value}`);
+                    });
+                }
+                if (payload.type === "error" || payload.success === false) {
+                    summary.hadErrorEvent = true;
+                }
+                if (payload.type === "complete") {
+                    logger.info("Upload stream completed.");
+                }
+            }),
+        });
+        if (summary.updated.size > 0) {
+            logger.success(`Updated ${summary.updated.size} file(s): ${Array.from(summary.updated).join(", ")}`);
+        }
+        if (summary.deleted.size > 0) {
+            logger.warn(`Deleted ${summary.deleted.size} file(s): ${Array.from(summary.deleted).join(", ")}`);
+        }
+        if (summary.errors.size > 0 || summary.hadErrorEvent) {
+            throw new Error("Upload completed with errors. Check the log for details.");
+        }
+    });
+}
+function performStandardUpload(session, basePath, body, query, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const endpoint = buildUploadEndpoint(session, basePath);
+        const url = (0, http_1.projectUrl)(session, endpoint, {
+            branch: query.branch,
+            environment_name: query.environment_name,
+        });
+        const fetcher = (0, http_1.createAmaFetch)(session);
+        const { data, error } = yield fetcher(url, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (error) {
+            const errorMessage = typeof error === "string"
+                ? error
+                : error instanceof Error
+                    ? error.message
+                    : (_a = error.message) !== null && _a !== void 0 ? _a : (error.status
+                        ? `HTTP ${error.status}`
+                        : "Unknown error");
+            throw new Error(`Request failed: ${errorMessage}`);
+        }
+        if (!data) {
+            throw new Error("No response data received from the server.");
+        }
+        if (!data.success) {
+            throw new Error(data.error || "Upload failed without a server error message.");
+        }
+        const payload = data.data;
+        if (!payload) {
+            logger.success("Server reported success with no additional details.");
+            return;
+        }
+        if (payload.updated && payload.updated.length > 0) {
+            logger.success(`Updated files: ${payload.updated.join(", ")}`);
+        }
+        if (payload.deleted && payload.deleted.length > 0) {
+            logger.warn(`Deleted files: ${payload.deleted.join(", ")}`);
+        }
+        if (payload.errors && Object.keys(payload.errors).length > 0) {
+            for (const [pathKey, value] of Object.entries(payload.errors)) {
+                logger.error(`Error for '${pathKey}': ${value}`);
+            }
+            throw new Error("Upload completed with file-specific errors.");
+        }
+    });
+}

package/dist/cli/commands/use.js

@@ -41,13 +41,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useCommand = useCommand;
 const commander_1 = require("commander");
-const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("../logger");
 const config_1 = require("../utils/config");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -56,7 +53,10 @@ function useCommand() {
         .description("Set authentication token for AMA project")
         .option("-t, --token <token>", "Authentication token")
         .option("-u, --url <url>", "Project base URL")
+        .option("-p, --project-id <id>", "Project identifier override")
+        .option("--verbose", "Enable verbose logging")
         .action((options) => __awaiter(this, void 0, void 0, function* () {
+        const logger = new logger_1.Logger(Boolean(options.verbose));
         const rlQuestion = (query) => {
             return new Promise((resolve) => {
                 const rl = require("readline").createInterface({
@@ -74,35 +74,47 @@ function useCommand() {
             const projectUrl = options.url || (yield rlQuestion("Enter the project URL: "));
             const authToken = options.token ||
                 (yield rlQuestion("Enter the authentication token: "));
+            const detectProjectId = (url) => {
+                const match = url.match(/\/projects\/([^/?#]+)/i);
+                return match === null || match === void 0 ? void 0 : match[1];
+            };
+            const detectedProjectId = detectProjectId(projectUrl);
+            const projectId = options.projectId || detectedProjectId;
+            if (!projectId) {
+                logger.warn("Project ID could not be detected from the URL. Rerun with --project-id to set it explicitly.");
+            }
             // Create .ama directory if it doesn't exist
             const amaDir = path.join(process.cwd(), ".ama");
             if (!fs.existsSync(amaDir)) {
                 fs.mkdirSync(amaDir, { recursive: true });
+                logger.verbose_log(`Created directory ${amaDir}.`);
             }
             // Add .gitignore if it doesn't exist or update it
             const gitignorePath = path.join(process.cwd(), ".gitignore");
             const gitignoreEntry = "\n# AMA configuration\n.ama/session.json\n";
             if (!fs.existsSync(gitignorePath)) {
                 fs.writeFileSync(gitignorePath, gitignoreEntry);
+                logger.verbose_log(`Created ${gitignorePath} with AMA ignore rules.`);
             }
             else {
                 const currentContent = fs.readFileSync(gitignorePath, "utf8");
                 if (!currentContent.includes(".ama/session.json")) {
                     fs.appendFileSync(gitignorePath, gitignoreEntry);
+                    logger.verbose_log(`Updated ${gitignorePath} with AMA ignore rules.`);
                 }
             }
-            const projectId = "proj_" + Math.random().toString(36).slice(2, 9);
             const configData = { token: authToken, projectId, url: projectUrl };
             (0, config_1.setConfig)(configData);
             // Save session data to .ama/session.json
             fs.writeFileSync(path.join(amaDir, "session.json"), JSON.stringify(configData, null, 2));
-            console.log(chalk_1.default.green("🔐 Successfully authenticated and joined project"));
-            console.log(chalk_1.default.yellow("⚠️  Warning: Keep your .ama/session.json file private and do not commit it to version control"));
-            console.log(chalk_1.default.blue("ℹ️  Note: Session file has been automatically added to .gitignore"));
+            logger.success("Authentication details saved for the project.");
+            logger.info(`Session file stored at ${path.join(amaDir, "session.json")}.`);
+            logger.warn("Keep your .ama/session.json file private and exclude it from version control.");
+            logger.info("Session file has been added to the project .gitignore file.");
         }
         catch (error) {
             const message = error instanceof Error ? error.message : "Unknown error";
-            console.error(chalk_1.default.red(`❌ Error: ${message}`));
+            logger.error(`Configuration update failed: ${message}`, error);
             process.exit(1);
         }
     }));

package/dist/cli/index.js

@@ -4,12 +4,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const migrate_1 = require("./commands/migrate");
 const use_1 = require("./commands/use");
+const upload_1 = require("./commands/upload");
+const generate_1 = require("./commands/generate");
 const program = new commander_1.Command()
     .name("ama")
     .description("AtMyApp CLI Tool")
     .version("1.0.0");
 program.addCommand((0, use_1.useCommand)());
 program.addCommand((0, migrate_1.migrateCommand)());
+program.addCommand((0, upload_1.uploadCommand)());
+program.addCommand((0, generate_1.generateCommand)());
 program.parseAsync(process.argv).catch((err) => {
     console.error("Error:", err.message);
     process.exit(1);

package/dist/cli/logger/index.d.ts

@@ -1,12 +1,14 @@
 /**
- * Logger utility to handle verbose logging
+ * Logger utility to handle verbose logging with consistent formatting.
  */
 export declare class Logger {
-    private verbose;
+    private readonly verbose;
     constructor(verbose: boolean);
     info(message: string): void;
     success(message: string): void;
+    warn(message: string): void;
     error(message: string, error?: unknown): void;
     verbose_log(message: string): void;
-    warn(message: string): void;
+    private write;
+    private formatErrorDetail;
 }

package/dist/cli/logger/index.js

@@ -5,30 +5,76 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
 const chalk_1 = __importDefault(require("chalk"));
+const LEVEL_CONFIG = {
+    info: { label: "INFO", style: (text) => chalk_1.default.blueBright.bold(text), method: "log" },
+    success: { label: "SUCCESS", style: (text) => chalk_1.default.greenBright.bold(text), method: "log" },
+    warn: { label: "WARN", style: (text) => chalk_1.default.yellowBright.bold(text), method: "warn" },
+    error: { label: "ERROR", style: (text) => chalk_1.default.redBright.bold(text), method: "error" },
+    verbose: { label: "VERBOSE", style: (text) => chalk_1.default.gray.bold(text), method: "log" },
+};
 /**
- * Logger utility to handle verbose logging
+ * Logger utility to handle verbose logging with consistent formatting.
  */
 class Logger {
     constructor(verbose) {
         this.verbose = verbose;
     }
     info(message) {
-        console.log(chalk_1.default.blue(message));
+        this.write("info", message);
     }
     success(message) {
-        console.log(chalk_1.default.green(message));
+        this.write("success", message);
+    }
+    warn(message) {
+        this.write("warn", message);
     }
     error(message, error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(chalk_1.default.red(message), error ? chalk_1.default.red(errorMessage) : "");
+        const detail = this.formatErrorDetail(error);
+        const formatted = detail ? `${message}\n${chalk_1.default.gray(detail)}` : message;
+        this.write("error", formatted);
     }
     verbose_log(message) {
-        if (this.verbose) {
-            console.log(chalk_1.default.cyan(`[VERBOSE] ${message}`));
+        if (!this.verbose) {
+            return;
         }
+        this.write("verbose", message);
     }
-    warn(message) {
-        console.warn(chalk_1.default.yellow(message));
+    write(level, message) {
+        const { label, style, method } = LEVEL_CONFIG[level];
+        const rawLabel = `[${label}]`;
+        const styledLabel = style(rawLabel);
+        const lines = message.split(/\r?\n/);
+        const continuationPrefix = " ".repeat(rawLabel.length + 1);
+        for (const [index, line] of lines.entries()) {
+            const output = index === 0 ? `${styledLabel} ${line}` : `${continuationPrefix}${line}`;
+            if (method === "warn") {
+                console.warn(output);
+            }
+            else if (method === "error") {
+                console.error(output);
+            }
+            else {
+                console.log(output);
+            }
+        }
+    }
+    formatErrorDetail(error) {
+        var _a;
+        if (!error) {
+            return undefined;
+        }
+        if (error instanceof Error) {
+            return (_a = error.stack) !== null && _a !== void 0 ? _a : error.message;
+        }
+        if (typeof error === "string") {
+            return error;
+        }
+        try {
+            return JSON.stringify(error, null, 2);
+        }
+        catch (_b) {
+            return String(error);
+        }
     }
 }
 exports.Logger = Logger;

package/dist/cli/utils/config.d.ts

@@ -1,10 +1,10 @@
-type Config = {
+export interface AmaConfig {
     token?: string;
     projectId?: string;
+    url?: string;
     include?: string[];
     description?: string;
     args?: Record<string, string>;
-};
-export declare function setConfig(config: Config): void;
-export declare function getConfig(): Config;
-export {};
+}
+export declare function setConfig(config: AmaConfig): void;
+export declare function getConfig(): AmaConfig;

package/dist/cli/utils/config.js

@@ -19,7 +19,6 @@ function ensureConfigDir() {
 }
 function setConfig(config) {
     ensureConfigDir();
-    (0, fs_1.writeFileSync)(CONFIG_PATH, JSON.stringify(config, null, 2));
     try {
         (0, fs_1.writeFileSync)(CONFIG_PATH, JSON.stringify(config, null, 2));
     }

package/dist/cli/utils/http.d.ts

@@ -0,0 +1,36 @@
+export interface AmaSession {
+    token: string;
+    projectId: string;
+    url: string;
+}
+export interface SessionOverrides {
+    token?: string;
+    projectId?: string;
+    url?: string;
+}
+export type AmaFetch = ReturnType<typeof createAmaFetch>;
+export interface SseEvent<T = unknown> {
+    event?: string;
+    id?: string;
+    retry?: number;
+    data: string;
+    parsed?: T;
+    raw: string;
+}
+export interface StreamSseOptions<T = unknown> {
+    url: string;
+    fetchInit?: RequestInit;
+    signal?: AbortSignal;
+    onEvent: (event: SseEvent<T>) => void | Promise<void>;
+}
+export declare function resolveSession(overrides?: SessionOverrides): AmaSession;
+export declare function createAmaFetch(session: AmaSession): import("@better-fetch/fetch").BetterFetch<{
+    baseURL: string;
+    headers: {
+        Authorization: string;
+    };
+    throw: false;
+}, unknown, unknown, unknown>;
+export declare function projectUrl(session: AmaSession, subPath: string, query?: Record<string, string | number | boolean | null | undefined>): string;
+export declare function streamSse<T = unknown>(options: StreamSseOptions<T>): Promise<void>;
+export declare function encodePathSegment(path: string): string;

package/dist/cli/utils/http.js

@@ -0,0 +1,242 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSession = resolveSession;
+exports.createAmaFetch = createAmaFetch;
+exports.projectUrl = projectUrl;
+exports.streamSse = streamSse;
+exports.encodePathSegment = encodePathSegment;
+const fetch_1 = require("@better-fetch/fetch");
+const config_1 = require("./config");
+function resolveSession(overrides = {}) {
+    var _a, _b, _c;
+    let config;
+    try {
+        config = (0, config_1.getConfig)();
+    }
+    catch (error) {
+        throw new Error("AMA session not configured. Run 'ama use' first or supply --url, --token, and --project-id options.");
+    }
+    const token = (_a = overrides.token) !== null && _a !== void 0 ? _a : config.token;
+    const projectId = (_b = overrides.projectId) !== null && _b !== void 0 ? _b : config.projectId;
+    const url = (_c = overrides.url) !== null && _c !== void 0 ? _c : config.url;
+    if (!token) {
+        throw new Error("Authentication token is missing. Run 'ama use' or provide it with --token.");
+    }
+    if (!url) {
+        throw new Error("Project URL is missing. Run 'ama use' or provide it with --url.");
+    }
+    if (!projectId) {
+        throw new Error("Project ID is missing. Ensure the URL contains /projects/{id} or pass --project-id.");
+    }
+    return {
+        token,
+        projectId,
+        url: stripTrailingSlashes(url),
+    };
+}
+function createAmaFetch(session) {
+    return (0, fetch_1.createFetch)({
+        baseURL: ensureTrailingSlash(session.url),
+        headers: {
+            Authorization: `Bearer ${session.token}`,
+        },
+        throw: false,
+    });
+}
+function projectUrl(session, subPath, query) {
+    const base = ensureTrailingSlash(session.url);
+    const cleanPath = subPath.replace(/^\/+/, "");
+    const url = new URL(cleanPath, base);
+    if (query) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(query)) {
+            if (value === undefined || value === null) {
+                continue;
+            }
+            params.append(key, typeof value === "boolean" ? String(value) : String(value));
+        }
+        const queryString = params.toString();
+        if (queryString) {
+            url.search = queryString;
+        }
+    }
+    return url.toString();
+}
+function streamSse(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { url, onEvent, signal, fetchInit = {} } = options;
+        const { signal: initSignal, headers: initHeaders } = fetchInit, restInit = __rest(fetchInit, ["signal", "headers"]);
+        const headers = new Headers(initHeaders !== null && initHeaders !== void 0 ? initHeaders : {});
+        if (!headers.has("Accept")) {
+            headers.set("Accept", "text/event-stream");
+        }
+        const requestInit = Object.assign(Object.assign({ method: (_a = restInit.method) !== null && _a !== void 0 ? _a : "GET" }, restInit), { headers, signal: signal !== null && signal !== void 0 ? signal : initSignal });
+        const response = yield fetch(url, requestInit);
+        if (!response.ok) {
+            const errorBody = yield safeReadText(response);
+            throw new Error(`Request failed with status ${response.status}: ${errorBody !== null && errorBody !== void 0 ? errorBody : "<no body>"}`);
+        }
+        if (!response.body) {
+            throw new Error("Streaming response body is not available.");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder("utf-8");
+        let buffer = "";
+        while (true) {
+            const { done, value } = yield reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            buffer = yield dispatchSseBuffer(buffer, onEvent);
+        }
+        buffer += decoder.decode();
+        yield dispatchSseBuffer(buffer, onEvent, true);
+    });
+}
+function encodePathSegment(path) {
+    return path
+        .split("/")
+        .map((segment) => segment === "" || segment === "." ? segment : encodeURIComponent(segment))
+        .join("/");
+}
+function stripTrailingSlashes(value) {
+    return value.replace(/\/+$/, "");
+}
+function ensureTrailingSlash(value) {
+    return value.endsWith("/") ? value : `${value}/`;
+}
+function dispatchSseBuffer(buffer_1, onEvent_1) {
+    return __awaiter(this, arguments, void 0, function* (buffer, onEvent, flush = false) {
+        let working = buffer;
+        while (true) {
+            const delimiter = nextDelimiter(working);
+            if (!delimiter) {
+                break;
+            }
+            const { index, length } = delimiter;
+            const rawEvent = working.slice(0, index);
+            working = working.slice(index + length);
+            if (!rawEvent.trim()) {
+                continue;
+            }
+            const event = parseSseEvent(rawEvent);
+            if (event) {
+                yield onEvent(event);
+            }
+        }
+        if (flush && working.trim()) {
+            const event = parseSseEvent(working);
+            if (event) {
+                yield onEvent(event);
+            }
+            return "";
+        }
+        return working;
+    });
+}
+function nextDelimiter(buffer) {
+    const lfIndex = buffer.indexOf("\n\n");
+    const crlfIndex = buffer.indexOf("\r\n\r\n");
+    if (lfIndex === -1 && crlfIndex === -1) {
+        return null;
+    }
+    if (lfIndex === -1) {
+        return { index: crlfIndex, length: 4 };
+    }
+    if (crlfIndex === -1) {
+        return { index: lfIndex, length: 2 };
+    }
+    return lfIndex < crlfIndex
+        ? { index: lfIndex, length: 2 }
+        : { index: crlfIndex, length: 4 };
+}
+function parseSseEvent(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const lines = trimmed.split(/\r?\n/);
+    const dataLines = [];
+    const event = {
+        data: "",
+        raw: trimmed,
+    };
+    for (const line of lines) {
+        if (!line) {
+            continue;
+        }
+        if (line.startsWith(":")) {
+            continue;
+        }
+        const separatorIndex = line.indexOf(":");
+        const field = separatorIndex === -1 ? line : line.slice(0, separatorIndex).trim();
+        const value = separatorIndex === -1
+            ? ""
+            : line
+                .slice(separatorIndex + 1)
+                .replace(/^\s+/, "");
+        switch (field) {
+            case "event":
+                event.event = value;
+                break;
+            case "data":
+                dataLines.push(value);
+                break;
+            case "id":
+                event.id = value;
+                break;
+            case "retry":
+                {
+                    const numeric = Number(value);
+                    if (!Number.isNaN(numeric)) {
+                        event.retry = numeric;
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    event.data = dataLines.join("\n");
+    if (event.data) {
+        try {
+            event.parsed = JSON.parse(event.data);
+        }
+        catch (error) {
+            // Non-JSON payloads are expected occasionally (e.g. [DONE])
+        }
+    }
+    return event;
+}
+function safeReadText(response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield response.text();
+        }
+        catch (error) {
+            return null;
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atmyapp/cli",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -28,7 +28,7 @@
   "license": "ISC",
   "description": "",
   "devDependencies": {
-    "@atmyapp/core": "^0.0.6",
+    "@atmyapp/core": "^0.0.11",
     "@types/jest": "^29.5.14",
     "@typescript-eslint/eslint-plugin": "^8.32.1",
     "@typescript-eslint/parser": "^8.32.1",
@@ -40,6 +40,7 @@
     "typescript": "^5.8.3"
   },
   "dependencies": {
+    "@better-fetch/fetch": "^1.1.18",
     "chalk": "^4.1.2",
     "commander": "^14.0.0",
     "fast-glob": "^3.3.3",