@atmyapp/cli 0.0.6 → 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;
 }