@atmyapp/cli 0.0.1

package/dist/cli/commands/use.js

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.useCommand = useCommand;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../utils/config");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function useCommand() {
+    return new commander_1.Command("use")
+        .description("Set authentication token for AMA project")
+        .option("-t, --token <token>", "Authentication token")
+        .option("-u, --url <url>", "Project base URL")
+        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        const rlQuestion = (query) => {
+            return new Promise((resolve) => {
+                const rl = require("readline").createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                rl.question(query, (answer) => {
+                    rl.close();
+                    resolve(answer);
+                });
+            });
+        };
+        try {
+            // Prompt user for URL and token if not provided
+            const projectUrl = options.url || (yield rlQuestion("Enter the project URL: "));
+            const authToken = options.token ||
+                (yield rlQuestion("Enter the authentication token: "));
+            // Create .ama directory if it doesn't exist
+            const amaDir = path.join(process.cwd(), ".ama");
+            if (!fs.existsSync(amaDir)) {
+                fs.mkdirSync(amaDir, { recursive: true });
+            }
+            // 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);
+            }
+            else {
+                const currentContent = fs.readFileSync(gitignorePath, "utf8");
+                if (!currentContent.includes(".ama/session.json")) {
+                    fs.appendFileSync(gitignorePath, gitignoreEntry);
+                }
+            }
+            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"));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            console.error(chalk_1.default.red(`❌ Error: ${message}`));
+            process.exit(1);
+        }
+    }));
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const migrate_1 = require("./commands/migrate");
+const use_1 = require("./commands/use");
+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.parseAsync(process.argv).catch((err) => {
+    console.error("Error:", err.message);
+    process.exit(1);
+});

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

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

package/dist/cli/logger/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Logger utility to handle verbose logging
+ */
+class Logger {
+    constructor(verbose) {
+        this.verbose = verbose;
+    }
+    info(message) {
+        console.log(chalk_1.default.blue(message));
+    }
+    success(message) {
+        console.log(chalk_1.default.green(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) : "");
+    }
+    verbose_log(message) {
+        if (this.verbose) {
+            console.log(chalk_1.default.cyan(`[VERBOSE] ${message}`));
+        }
+    }
+    warn(message) {
+        console.warn(chalk_1.default.yellow(message));
+    }
+}
+exports.Logger = Logger;

package/dist/cli/test-migrate.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/test-migrate.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const migrate_1 = require("./commands/migrate");
+// Create and execute the migrate command
+const command = (0, migrate_1.migrateCommand)();
+command.parse(process.argv);
+// Sample usage:
+// npm run build
+// node dist/cli/test-migrate.js

package/dist/cli/types/migrate.d.ts

@@ -0,0 +1,34 @@
+export interface Content {
+    path: string;
+    structure: any;
+    type?: string;
+}
+export interface EventConfig {
+    columns: string[];
+}
+export interface OutputDefinition {
+    description: string;
+    definitions: Record<string, {
+        structure: any;
+        type?: string;
+    }>;
+    events: Record<string, EventConfig>;
+    args: any[];
+    metadata?: any;
+}
+export interface MigrateOptions {
+    dryRun: boolean;
+    verbose: boolean;
+    tsconfig: string;
+    continueOnError: boolean;
+}
+export interface TypeTransformer {
+    canTransform: (obj: any) => boolean;
+    transform: (obj: any) => any;
+}
+export interface ProcessingResult {
+    contents: Content[];
+    errors: string[];
+    successCount: number;
+    failureCount: number;
+}

package/dist/cli/types/migrate.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/cli/utils/config.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setConfig = setConfig;
+exports.getConfig = getConfig;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const CONFIG_PATH = path_1.default.join(process.cwd(), "./.ama/session.json");
+const CONFIG_DIR = path_1.default.dirname(CONFIG_PATH);
+function ensureConfigDir() {
+    try {
+        (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+    }
+    catch (error) {
+        throw new Error(`Failed to create config directory: ${error instanceof Error ? error.message : error}`);
+    }
+}
+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));
+    }
+    catch (error) {
+        throw new Error(`Failed to save config: ${error instanceof Error ? error.message : error}`);
+    }
+}
+function getConfig() {
+    ensureConfigDir();
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(CONFIG_PATH, "utf-8"));
+    }
+    catch (error) {
+        throw new Error(`Failed to read config: ${error instanceof Error ? error.message : error}`);
+    }
+}

package/dist/cli/utils/content-processor.d.ts

@@ -0,0 +1,6 @@
+import { Logger } from "../logger";
+import { Content, OutputDefinition } from "../types/migrate";
+import { definitionPipeline } from "./definition-processor";
+export declare function determineContentType(content: Content): string;
+export declare function generateOutput(contents: Content[], config: any, logger: Logger): OutputDefinition;
+export { definitionPipeline };

package/dist/cli/utils/content-processor.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definitionPipeline = void 0;
+exports.determineContentType = determineContentType;
+exports.generateOutput = generateOutput;
+const type_transformers_1 = require("./type-transformers");
+const definition_processor_1 = require("./definition-processor");
+Object.defineProperty(exports, "definitionPipeline", { enumerable: true, get: function () { return definition_processor_1.definitionPipeline; } });
+// Initialize the pipeline with built-in components
+function initializePipeline() {
+    // Always register built-in components
+    (0, definition_processor_1.registerBuiltInProcessors)();
+    (0, definition_processor_1.registerBuiltInValidators)();
+    (0, definition_processor_1.registerBuiltInOutputTransformers)();
+}
+// Determines the content type based on its structure and path
+function determineContentType(content) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    // Extract file extension
+    const fileExt = (_a = content.path.split(".").pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    // Check for event types
+    if (((_b = content.structure) === null || _b === void 0 ? void 0 : _b.type) === "event" ||
+        ((_e = (_d = (_c = content.structure) === null || _c === void 0 ? void 0 : _c.properties) === null || _d === void 0 ? void 0 : _d.type) === null || _e === void 0 ? void 0 : _e.const) === "event" ||
+        ((_f = content.structure) === null || _f === void 0 ? void 0 : _f.__amatype) === "AmaEventDef") {
+        return "event";
+    }
+    // Check for image types based on structure or extension
+    if (((_g = content.structure) === null || _g === void 0 ? void 0 : _g.__amatype) === "AmaImageDef") {
+        return "image";
+    }
+    // Check for file types
+    if (((_h = content.structure) === null || _h === void 0 ? void 0 : _h.__amatype) === "AmaFileDef") {
+        return "file";
+    }
+    // Default type for other content
+    return "jsonx";
+}
+// Extracts event configuration from event content
+function extractEventConfig(content) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    try {
+        let columns = [];
+        let eventId = "";
+        // Try to extract from different possible structures
+        if ((_c = (_b = (_a = content.structure) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.columns) === null || _c === void 0 ? void 0 : _c.const) {
+            columns = content.structure.properties.columns.const;
+        }
+        else if ((_g = (_f = (_e = (_d = content.structure) === null || _d === void 0 ? void 0 : _d.properties) === null || _e === void 0 ? void 0 : _e.columns) === null || _f === void 0 ? void 0 : _f.items) === null || _g === void 0 ? void 0 : _g.const) {
+            // Handle array of constants
+            columns = content.structure.properties.columns.items.const;
+        }
+        else if ((_h = content.structure) === null || _h === void 0 ? void 0 : _h.columns) {
+            columns = content.structure.columns;
+        }
+        // Extract event ID
+        if ((_l = (_k = (_j = content.structure) === null || _j === void 0 ? void 0 : _j.properties) === null || _k === void 0 ? void 0 : _k.id) === null || _l === void 0 ? void 0 : _l.const) {
+            eventId = content.structure.properties.id.const;
+        }
+        else if ((_m = content.structure) === null || _m === void 0 ? void 0 : _m.id) {
+            eventId = content.structure.id;
+        }
+        if (columns.length > 0) {
+            return { columns };
+        }
+    }
+    catch (error) {
+        // Silent failure, let the caller handle
+    }
+    return null;
+}
+// Generates the final output definition using the processing pipeline
+function generateOutput(contents, config, logger) {
+    // Initialize the pipeline with built-in components
+    initializePipeline();
+    logger.verbose_log("Processing contents through definition pipeline");
+    // Process definitions through the pipeline
+    const { processedContents, validationResults } = definition_processor_1.definitionPipeline.processDefinitions(contents, config, logger);
+    // Log validation summary
+    const validationErrors = validationResults.reduce((sum, result) => sum + result.errors.length, 0);
+    const validationWarnings = validationResults.reduce((sum, result) => sum + result.warnings.length, 0);
+    if (validationErrors > 0) {
+        logger.warn(`Found ${validationErrors} validation errors`);
+    }
+    if (validationWarnings > 0) {
+        logger.warn(`Found ${validationWarnings} validation warnings`);
+    }
+    // Apply special type transformations to processed contents
+    logger.verbose_log("Applying special type transformations");
+    const transformedContents = processedContents.map((content) => {
+        logger.verbose_log(`Transforming special types for path: ${content.path}`);
+        return Object.assign(Object.assign({}, content), { structure: (0, type_transformers_1.processSpecialTypes)(content.structure) });
+    });
+    // Separate events from regular definitions
+    const events = {};
+    const definitions = {};
+    transformedContents.forEach((content) => {
+        var _a, _b, _c, _d;
+        const contentType = determineContentType(content);
+        if (contentType === "event") {
+            logger.verbose_log(`Processing event: ${content.path}`);
+            // Extract event ID from path or structure
+            let eventId = content.path;
+            if ((_c = (_b = (_a = content.structure) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.id) === null || _c === void 0 ? void 0 : _c.const) {
+                eventId = content.structure.properties.id.const;
+            }
+            else if ((_d = content.structure) === null || _d === void 0 ? void 0 : _d.id) {
+                eventId = content.structure.id;
+            }
+            const eventConfig = extractEventConfig(content);
+            if (eventConfig) {
+                events[eventId] = eventConfig;
+                logger.verbose_log(`Added event "${eventId}" with columns: ${eventConfig.columns.join(", ")}`);
+            }
+            else {
+                logger.warn(`Failed to extract event configuration for ${content.path}`);
+            }
+        }
+        else {
+            // Regular definition
+            definitions[content.path] = {
+                type: content.type,
+                structure: content.structure,
+            };
+        }
+    });
+    logger.verbose_log("Generating base output definition");
+    const baseOutput = {
+        description: config.description || "AMA Definitions",
+        definitions,
+        events,
+        args: config.args || {},
+    };
+    // Transform the final output through the pipeline
+    logger.verbose_log("Applying output transformations");
+    const finalOutput = definition_processor_1.definitionPipeline.transformOutput(baseOutput, config, logger);
+    // Log pipeline statistics
+    const stats = definition_processor_1.definitionPipeline.getStats();
+    logger.verbose_log(`Pipeline used ${stats.processors} processors, ${stats.validators} validators, ${stats.transformers} transformers`);
+    logger.verbose_log(`Generated ${Object.keys(finalOutput.definitions).length} definitions and ${Object.keys(finalOutput.events).length} events`);
+    return finalOutput;
+}

package/dist/cli/utils/definition-processor.d.ts

@@ -0,0 +1,61 @@
+import { Logger } from "../logger";
+import { Content, OutputDefinition } from "../types/migrate";
+export interface DefinitionProcessor {
+    name: string;
+    process: (content: Content, context: ProcessingContext) => Content | null;
+}
+export interface ProcessingContext {
+    logger: Logger;
+    config: any;
+    allContents: Content[];
+    currentIndex: number;
+}
+export interface OutputTransformer {
+    name: string;
+    transform: (output: OutputDefinition, context: ProcessingContext) => OutputDefinition;
+}
+export interface ValidationRule {
+    name: string;
+    validate: (content: Content, context: ProcessingContext) => ValidationResult;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+declare class DefinitionProcessingPipeline {
+    private processors;
+    private outputTransformers;
+    private validators;
+    addProcessor(processor: DefinitionProcessor): void;
+    addOutputTransformer(transformer: OutputTransformer): void;
+    addValidator(validator: ValidationRule): void;
+    processDefinitions(contents: Content[], config: any, logger: Logger): {
+        processedContents: Content[];
+        validationResults: ValidationResult[];
+    };
+    transformOutput(output: OutputDefinition, config: any, logger: Logger): OutputDefinition;
+    private validateContent;
+    clear(): void;
+    getStats(): {
+        processors: number;
+        transformers: number;
+        validators: number;
+    };
+}
+export declare const definitionPipeline: DefinitionProcessingPipeline;
+export declare const builtInProcessors: {
+    typeDetector: DefinitionProcessor;
+    pathNormalizer: DefinitionProcessor;
+};
+export declare const builtInValidators: {
+    pathValidator: ValidationRule;
+    duplicatePathValidator: ValidationRule;
+};
+export declare const builtInOutputTransformers: {
+    metadataEnricher: OutputTransformer;
+};
+export declare function registerBuiltInProcessors(): void;
+export declare function registerBuiltInValidators(): void;
+export declare function registerBuiltInOutputTransformers(): void;
+export {};