@archlast/cli 0.0.1

package/dist/commands/build.d.ts

@@ -0,0 +1,6 @@
+interface BuildOptions {
+    path?: string;
+}
+export declare function buildCommand(options: BuildOptions): Promise<void>;
+export {};
+//# sourceMappingURL=build.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/commands/build.ts"],"names":[],"mappings":"AAMA,UAAU,YAAY;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA6CvE"}

package/dist/commands/build.js

@@ -0,0 +1,36 @@
+import chalk from "chalk";
+import ora from "ora";
+import { CodeAnalyzer } from "../analyzer";
+import { TypeGenerator } from "../generator";
+export async function buildCommand(options) {
+    const archlastPath = options.path || ".";
+    console.log(chalk.blue.bold("🔨 Archlast Build\n"));
+    const analyzer = new CodeAnalyzer(archlastPath);
+    const generator = new TypeGenerator(archlastPath);
+    const spinner = ora("Analyzing code...").start();
+    try {
+        const analysis = await analyzer.analyze();
+        await generator.generate(analysis);
+        spinner.succeed(chalk.green(`✅ Generated types for ${analysis.functions.length} function(s)`));
+        // Show function breakdown
+        if (analysis.functions.length > 0) {
+            const byType = analysis.functions.reduce((acc, fn) => {
+                acc[fn.type] = (acc[fn.type] || 0) + 1;
+                return acc;
+            }, {});
+            const breakdown = Object.entries(byType)
+                .map(([type, count]) => `${count} ${type}(s)`)
+                .join(", ");
+            console.log(chalk.gray(`   (${breakdown})`));
+        }
+        console.log(chalk.gray("\nGenerated files:"));
+        console.log(chalk.gray("  • _generated/api.ts"));
+        console.log(chalk.gray("  • _generated/server.ts"));
+        console.log(chalk.gray("  • _generated/index.ts"));
+    }
+    catch (error) {
+        spinner.fail(chalk.red("Build failed"));
+        console.error(error);
+        process.exit(1);
+    }
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,8 @@
+interface ConfigOptions {
+    path?: string;
+    config?: string;
+    json?: boolean;
+}
+export declare function configCommand(options: ConfigOptions): Promise<void>;
+export {};
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"AAGA,UAAU,aAAa;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBzE"}

package/dist/commands/config.js

@@ -0,0 +1,23 @@
+import chalk from "chalk";
+import { loadDockerConfig } from "../docker/config";
+export async function configCommand(options) {
+    const config = loadDockerConfig({
+        path: options.path,
+        configFile: options.config,
+    });
+    if (options.json) {
+        console.log(JSON.stringify(config, null, 2));
+        return;
+    }
+    console.log(chalk.blue.bold("Archlast Docker Config\n"));
+    console.log(`Project:   ${config.projectPath}`);
+    console.log(`Config:    ${config.configFilePath ?? "none"}`);
+    console.log(`Env file:  ${config.envFilePath ?? "none"}`);
+    console.log(`Image:     ${config.image}:${config.tag}`);
+    console.log(`Container: ${config.containerName}`);
+    console.log(`Port:      ${config.port}`);
+    console.log(`Volume:    ${config.dataVolumeName}`);
+    console.log(`Config dir: ${config.configDir}`);
+    console.log(`Deploy dir: ${config.deployDir}`);
+    console.log(`Compose:   ${config.composePath}`);
+}

package/dist/commands/data.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+/**
+ * Data command group for backup, export, import operations
+ */
+export declare const dataCommand: Command;
+//# sourceMappingURL=data.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../src/commands/data.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA4DpC;;GAEG;AACH,eAAO,MAAM,WAAW,SAE4C,CAAC"}

package/dist/commands/data.js

@@ -0,0 +1,300 @@
+import chalk from "chalk";
+import ora from "ora";
+import { Command } from "commander";
+import * as fs from "fs";
+import * as path from "path";
+const BETTER_AUTH_API_KEY_PREFIX = "arch_";
+/**
+ * Data command group for backup, export, import operations
+ */
+export const dataCommand = new Command("data")
+    .description("Data management commands (backup, export, import)")
+    .option("--server <url>", "Server URL", "http://localhost:4000");
+/**
+ * Get API key from environment
+ */
+async function getAuthCredentials(server) {
+    // Check API key first
+    const apiKey = process.env.ARCHLAST_API_KEY;
+    if (apiKey) {
+        return apiKey;
+    }
+    // If no token, try to read from .env file
+    const envPath = path.join(process.cwd(), ".env");
+    if (fs.existsSync(envPath)) {
+        const envContent = fs.readFileSync(envPath, "utf-8");
+        const keyMatch = envContent.match(/ARCHLAST_API_KEY=(.+)/);
+        if (keyMatch && keyMatch[1]) {
+            return keyMatch[1].trim();
+        }
+    }
+    throw new Error("API key not found. Set ARCHLAST_API_KEY environment variable, or add it to .env file");
+}
+/**
+ * Make authenticated request to server
+ */
+async function apiRequest(url, options = {}, token) {
+    const headers = {
+        ...options.headers,
+        "Content-Type": "application/json",
+        "x-api-key": token,
+    };
+    return fetch(url, {
+        ...options,
+        headers,
+    });
+}
+/**
+ * Create a snapshot
+ */
+dataCommand
+    .command("snapshot")
+    .description("Create a database snapshot")
+    .option("-n, --name <name>", "Snapshot name")
+    .option("--include-sqlite", "Include SQLite export (default: false)", false)
+    .action(async function (options) {
+    const parent = this.parent;
+    const serverOpts = parent?.opts() || {};
+    const server = serverOpts.server || "http://localhost:4000";
+    const spinner = ora("Creating snapshot...").start();
+    try {
+        const token = await getAuthCredentials(server);
+        const response = await apiRequest(`${server}/_archlast/admin/backup/snapshot`, {
+            method: "POST",
+            body: JSON.stringify({ name: options.name }),
+        }, token);
+        const result = (await response.json());
+        if (!response.ok || !result.success) {
+            spinner.fail(chalk.red(`Failed to create snapshot: ${result.error || "Unknown error"}`));
+            process.exit(1);
+        }
+        spinner.succeed(chalk.green(`✅ Snapshot created: ${result.snapshotFile}`));
+        console.log(chalk.gray(`  Records: ${result.recordCount}`));
+        console.log(chalk.gray(`  Collections: ${result.collections.length}`));
+    }
+    catch (error) {
+        spinner.fail(chalk.red("Failed to create snapshot"));
+        console.error(error);
+        process.exit(1);
+    }
+});
+/**
+ * Export data to a file
+ */
+dataCommand
+    .command("export <outputFile>")
+    .description("Export all data to a ZIP file")
+    .option("-f, --format <format>", "Export format: zip or json", "zip")
+    .action(async function (outputFile, options) {
+    const parent = this.parent;
+    const serverOpts = parent?.opts() || {};
+    const server = serverOpts.server || "http://localhost:4000";
+    const spinner = ora("Exporting data...").start();
+    try {
+        const token = await getAuthCredentials(server);
+        const response = await apiRequest(`${server}/_archlast/admin/backup/export`, {}, token);
+        if (!response.ok) {
+            const result = (await response.json());
+            spinner.fail(chalk.red(`Failed to export: ${result.error || "Unknown error"}`));
+            process.exit(1);
+        }
+        const outputPath = path.resolve(outputFile);
+        if (options.format === "json") {
+            const data = (await response.json());
+            await fs.promises.writeFile(outputPath, JSON.stringify(data, null, 2), "utf-8");
+            const collectionCount = Object.keys(data.collections || {}).length;
+            const totalRecords = Object.values(data.collections || {}).reduce((sum, col) => sum + (col?.count || 0), 0);
+            spinner.succeed(chalk.green(`✅ Exported to ${outputFile}`));
+            console.log(chalk.gray(`  Collections: ${collectionCount}`));
+            console.log(chalk.gray(`  Records: ${totalRecords}`));
+        }
+        else {
+            const arrayBuffer = await response.arrayBuffer();
+            await fs.promises.writeFile(outputPath, Buffer.from(arrayBuffer));
+            spinner.succeed(chalk.green(`✅ Exported to ${outputFile}`));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red("Failed to export data"));
+        console.error(error);
+        process.exit(1);
+    }
+});
+/**
+ * Restore from a snapshot
+ */
+dataCommand
+    .command("restore <snapshotFile>")
+    .description("Restore database from a snapshot")
+    .action(async function (snapshotFile) {
+    const parent = this.parent;
+    const serverOpts = parent?.opts() || {};
+    const server = serverOpts.server || "http://localhost:4000";
+    const spinner = ora("Restoring snapshot...").start();
+    try {
+        const token = await getAuthCredentials(server);
+        const response = await apiRequest(`${server}/_archlast/admin/backup/restore`, {
+            method: "POST",
+            body: JSON.stringify({ snapshotFile }),
+        }, token);
+        const result = (await response.json());
+        if (!response.ok || !result.success) {
+            spinner.fail(chalk.red(`Failed to restore: ${result.error || "Unknown error"}`));
+            process.exit(1);
+        }
+        spinner.succeed(chalk.green(`✅ Restored ${result.recordsImported} records`));
+        console.log(chalk.gray(`  Collections: ${result.collections.length}`));
+    }
+    catch (error) {
+        spinner.fail(chalk.red("Failed to restore snapshot"));
+        console.error(error);
+        process.exit(1);
+    }
+});
+/**
+ * Export data to a file
+ */
+dataCommand
+    .command("export <outputFile>")
+    .description("Export all data to a JSON file")
+    .action(async function (outputFile) {
+    const parent = this.parent;
+    const serverOpts = parent?.opts() || {};
+    const server = serverOpts.server || "http://localhost:4000";
+    const spinner = ora("Exporting data...").start();
+    try {
+        const token = await getAuthCredentials(server);
+        const response = await apiRequest(`${server}/_archlast/admin/backup/export`, {}, token);
+        if (!response.ok) {
+            const result = (await response.json());
+            spinner.fail(chalk.red(`Failed to export: ${result.error || "Unknown error"}`));
+            process.exit(1);
+        }
+        const data = (await response.json());
+        // Write to file
+        const outputPath = path.resolve(outputFile);
+        await fs.promises.writeFile(outputPath, JSON.stringify(data, null, 2), "utf-8");
+        const collectionCount = Object.keys(data.collections || {}).length;
+        const totalRecords = Object.values(data.collections || {}).reduce((sum, col) => sum + (col?.count || 0), 0);
+        spinner.succeed(chalk.green(`✅ Exported to ${outputFile}`));
+        console.log(chalk.gray(`  Collections: ${collectionCount}`));
+        console.log(chalk.gray(`  Records: ${totalRecords}`));
+    }
+    catch (error) {
+        spinner.fail(chalk.red("Failed to export data"));
+        console.error(error);
+        process.exit(1);
+    }
+});
+/**
+ * Import data from a file
+ */
+dataCommand
+    .command("import <inputFile>")
+    .description("Import data from a JSON or ZIP file (auto-detects format)")
+    .option("-s, --strategy <strategy>", "Import strategy: replace or merge", "merge")
+    .action(async function (inputFile, options) {
+    const parent = this.parent;
+    const serverOpts = parent?.opts() || {};
+    const server = serverOpts.server || "http://localhost:4000";
+    const spinner = ora("Importing data...").start();
+    try {
+        const inputPath = path.resolve(inputFile);
+        if (!fs.existsSync(inputPath)) {
+            spinner.fail(chalk.red(`File not found: ${inputFile}`));
+            process.exit(1);
+        }
+        const buffer = await fs.promises.readFile(inputPath);
+        const isZip = isZipFile(buffer);
+        if (isZip) {
+            const formData = new FormData();
+            formData.append("file", new Blob([buffer]), path.basename(inputFile));
+            formData.append("strategy", options.strategy);
+            formData.append("verifyChecksums", "true");
+            const token = await getAuthCredentials(server);
+            const response = await fetch(`${server}/_archlast/admin/backup/restore`, {
+                method: "POST",
+                headers: {
+                    "x-api-key": token,
+                },
+                body: formData,
+            });
+            const result = (await response.json());
+            if (!response.ok || !result.success) {
+                spinner.fail(chalk.red(`Failed to import: ${result.error || "Unknown error"}`));
+                process.exit(1);
+            }
+            spinner.succeed(chalk.green(`✅ Imported ${result.recordsImported} records`));
+            console.log(chalk.gray(`  Format: ZIP`));
+            console.log(chalk.gray(`  Collections: ${result.collections.length}`));
+        }
+        else {
+            const content = buffer.toString("utf-8");
+            const data = JSON.parse(content);
+            const token = await getAuthCredentials(server);
+            const response = await apiRequest(`${server}/_archlast/admin/backup/import`, {
+                method: "POST",
+                body: JSON.stringify({
+                    data,
+                    strategy: options.strategy,
+                }),
+            }, token);
+            const result = (await response.json());
+            if (!response.ok || !result.success) {
+                spinner.fail(chalk.red(`Failed to import: ${result.error || "Unknown error"}`));
+                process.exit(1);
+            }
+            spinner.succeed(chalk.green(`✅ Imported ${result.recordsImported} records`));
+            console.log(chalk.gray(`  Format: JSON`));
+            console.log(chalk.gray(`  Strategy: ${options.strategy}`));
+            console.log(chalk.gray(`  Collections: ${result.collections.length}`));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red("Failed to import data"));
+        console.error(error);
+        process.exit(1);
+    }
+});
+/**
+ * Check if a buffer is a ZIP file by checking magic bytes
+ */
+function isZipFile(buffer) {
+    return (buffer.length >= 4 &&
+        buffer[0] === 0x50 &&
+        buffer[1] === 0x4b &&
+        buffer[2] === 0x03 &&
+        buffer[3] === 0x04);
+}
+/**
+ * Delete a snapshot
+ */
+dataCommand
+    .command("delete <snapshotFile>")
+    .description("Delete a snapshot file (supports .json and .zip)")
+    .action(async function (snapshotFile) {
+    const parent = this.parent;
+    const serverOpts = parent?.opts() || {};
+    const server = serverOpts.server || "http://localhost:4000";
+    const spinner = ora("Deleting snapshot...").start();
+    try {
+        const token = await getAuthCredentials(server);
+        const filename = snapshotFile.endsWith(".json") || snapshotFile.endsWith(".zip")
+            ? snapshotFile
+            : `${snapshotFile}.zip`;
+        const response = await apiRequest(`${server}/_archlast/admin/backup/snapshot/${filename}`, {
+            method: "DELETE",
+        }, token);
+        const result = (await response.json());
+        if (!response.ok || !result.success) {
+            spinner.fail(chalk.red(`Failed to delete: ${result.error || "Unknown error"}`));
+            process.exit(1);
+        }
+        spinner.succeed(chalk.green(`✅ Deleted snapshot: ${filename}`));
+    }
+    catch (error) {
+        spinner.fail(chalk.red("Failed to delete snapshot"));
+        console.error(error);
+        process.exit(1);
+    }
+});

package/dist/commands/deploy.d.ts

@@ -0,0 +1,9 @@
+interface DeployOptions {
+    path?: string;
+    server?: string;
+    maxPoll?: number;
+    includeNodeModules?: boolean;
+}
+export declare function deployCommand(options: DeployOptions): Promise<void>;
+export {};
+//# sourceMappingURL=deploy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/commands/deploy.ts"],"names":[],"mappings":"AAQA,UAAU,aAAa;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAwFzE"}

package/dist/commands/deploy.js

@@ -0,0 +1,59 @@
+import chalk from "chalk";
+import ora from "ora";
+import { CodeAnalyzer } from "../analyzer";
+import { TypeGenerator } from "../generator";
+import { CodeUploader } from "../uploader";
+export async function deployCommand(options) {
+    const archlastPath = options.path || ".";
+    const maxPoll = parseInt(String(options.maxPoll || "30"), 10);
+    console.log(chalk.blue.bold("🚀 Archlast Deploy\n"));
+    const analyzer = new CodeAnalyzer(archlastPath);
+    const generator = new TypeGenerator(archlastPath);
+    const uploader = new CodeUploader(options.server || "http://localhost:4000", archlastPath);
+    const spinner = ora("Checking server availability...").start();
+    try {
+        // Poll server to ensure it's reachable
+        const serverReady = await uploader.pollServer(maxPoll, 1000);
+        if (!serverReady) {
+            spinner.fail(chalk.red(`Server not reachable after ${maxPoll} retries`));
+            process.exit(1);
+        }
+        spinner.text = "Analyzing code...";
+        const analysis = await analyzer.analyze();
+        spinner.text = "Generating types...";
+        await generator.generate(analysis);
+        spinner.text = "Checking for changes...";
+        const diffCheck = await uploader.checkHashDiff();
+        if (!diffCheck.hasChanges) {
+            spinner.succeed(chalk.green("✅ No changes detected, skipping upload"));
+            console.log(chalk.gray(`\n🌐 Server: ${options.server || "http://localhost:4000"}`));
+            console.log(chalk.green("\n✨ Already up to date!\n"));
+            return;
+        }
+        spinner.text = "Uploading to server...";
+        const uploadResult = await uploader.uploadDelta();
+        if (!uploadResult.success) {
+            spinner.fail(chalk.red(`Upload failed: ${uploadResult.message}`));
+            process.exit(1);
+        }
+        const deploymentType = uploadResult.deploymentType === "delta" ? "Δ (Delta)" : "Full";
+        spinner.succeed(chalk.green(`✅ Deployed ${analysis.functions.length} function(s) to ${options.server} [${deploymentType}]`));
+        console.log(chalk.gray("\nFunctions:"));
+        analysis.functions.forEach((f) => {
+            console.log(chalk.gray(`  - ${f.name} (${f.type})`));
+        });
+        if (analysis.schema) {
+            console.log(chalk.gray("\n✓ Schema included"));
+        }
+        if (diffCheck.reason) {
+            console.log(chalk.gray(`\n📝 Change reason: ${diffCheck.reason}`));
+        }
+        console.log(chalk.green(`\n🌐 Server: ${options.server || "http://localhost:4000"}`));
+        console.log(chalk.green("\n✨ Deployment complete!\n"));
+    }
+    catch (error) {
+        spinner.fail(chalk.red("Deployment failed"));
+        console.error(error);
+        process.exit(1);
+    }
+}

package/dist/commands/dev.d.ts

@@ -0,0 +1,10 @@
+interface DevOptions {
+    port?: string;
+    path?: string;
+    server?: string;
+    maxPoll?: number;
+    includeNodeModules?: boolean;
+}
+export declare function devCommand(options: DevOptions): Promise<void>;
+export {};
+//# sourceMappingURL=dev.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/commands/dev.ts"],"names":[],"mappings":"AAWA,UAAU,UAAU;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAmMnE"}

package/dist/commands/dev.js

@@ -0,0 +1,132 @@
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+import { FileWatcher } from "../watcher";
+import { CodeAnalyzer, CodeDiffer } from "../analyzer";
+import { TypeGenerator } from "../generator";
+import { CodeUploader } from "../uploader";
+import { listenToServerEvents } from "../events-listener";
+export async function devCommand(options) {
+    const archlastPath = options.path || ".";
+    const maxPoll = parseInt(String(options.maxPoll || "30"), 10);
+    console.log(chalk.blue.bold("🚀 Archlast Dev Mode\n"));
+    const analyzer = new CodeAnalyzer(archlastPath);
+    const differ = new CodeDiffer();
+    const generator = new TypeGenerator(archlastPath);
+    const watcher = new FileWatcher(archlastPath);
+    const uploader = new CodeUploader(options.server || "http://localhost:4000", archlastPath);
+    let previousAnalysis = null;
+    // Initial analysis
+    const spinner = ora("Checking server availability...").start();
+    try {
+        // Poll server to ensure it's reachable
+        const serverReady = await uploader.pollServer(maxPoll, 1000);
+        if (!serverReady) {
+            spinner.fail(chalk.red(`Server not reachable after ${maxPoll} retries`));
+            console.log(chalk.yellow("\n💡 Tip: Make sure the Archlast server is running before starting dev mode"));
+            process.exit(1);
+        }
+        spinner.text = "Analyzing code...";
+        const analysis = await analyzer.analyze();
+        await generator.generate(analysis);
+        spinner.text = "Checking for changes...";
+        const diffCheck = await uploader.checkHashDiff();
+        if (!diffCheck.hasChanges) {
+            spinner.succeed(chalk.green(`Found ${analysis.functions.length} function(s) | Generated types | No changes detected`));
+            console.log(chalk.gray("\nWatching for changes...\n"));
+        }
+        else {
+            spinner.text = "Uploading to server...";
+            const uploadResult = await uploader.uploadDelta();
+            if (uploadResult.success) {
+                const deploymentType = uploadResult.deploymentType === "delta" ? "Δ" : "Full";
+                spinner.succeed(chalk.green(`Found ${analysis.functions.length} function(s) | Generated types | Uploaded (${deploymentType}) to ${options.server || "http://localhost:4000"}`));
+            }
+            else {
+                spinner.warn(chalk.yellow(`Found ${analysis.functions.length} function(s) | Generated types | Upload failed: ${uploadResult.message}`));
+            }
+            console.log(chalk.gray("\nWatching for changes...\n"));
+        }
+        previousAnalysis = analysis;
+    }
+    catch (error) {
+        spinner.fail(chalk.red("Analysis failed"));
+        console.error(error);
+        process.exit(1);
+    }
+    // Watch for changes
+    watcher.on("change", async (event) => {
+        const relativePath = path.relative(process.cwd(), event.path);
+        console.log(chalk.yellow(`\n📝 ${event.type}: ${relativePath}`));
+        const analyzeSpinner = ora("Re-analyzing...").start();
+        try {
+            const newAnalysis = await analyzer.analyze();
+            if (previousAnalysis) {
+                const diff = differ.diff(previousAnalysis, newAnalysis);
+                if (diff.added.length > 0) {
+                    analyzeSpinner.info(chalk.green(`✨ Added ${diff.added.length} function(s)`));
+                    diff.added.forEach((f) => console.log(chalk.green(`   + ${f.name} (${f.type})`)));
+                }
+                if (diff.modified.length > 0) {
+                    analyzeSpinner.info(chalk.blue(`🔄 Modified ${diff.modified.length} function(s)`));
+                    diff.modified.forEach((f) => console.log(chalk.blue(`   ~ ${f.name} (${f.type})`)));
+                }
+                if (diff.removed.length > 0) {
+                    analyzeSpinner.info(chalk.red(`🗑️  Removed ${diff.removed.length} function(s)`));
+                    diff.removed.forEach((f) => console.log(chalk.red(`   - ${f.name} (${f.type})`)));
+                }
+                if (diff.schemaChanged) {
+                    analyzeSpinner.info(chalk.magenta("📊 Schema changed"));
+                }
+            }
+            await generator.generate(newAnalysis);
+            analyzeSpinner.text = "Uploading changes...";
+            const uploadResult = await uploader.uploadDelta();
+            previousAnalysis = newAnalysis;
+            if (uploadResult.success) {
+                const deploymentType = uploadResult.deploymentType === "delta" ? "Δ" : "Full";
+                analyzeSpinner.succeed(chalk.green(`✅ Types regenerated | Uploaded (${deploymentType})`));
+            }
+            else {
+                analyzeSpinner.warn(chalk.yellow(`✅ Types regenerated | Upload failed: ${uploadResult.message}`));
+            }
+            console.log(chalk.gray("\nWatching for changes...\n"));
+        }
+        catch (error) {
+            analyzeSpinner.fail(chalk.red("Analysis failed"));
+            console.error(error);
+        }
+    });
+    watcher.start();
+    // Start listening to server events for reactive deployments
+    const serverUrl = options.server || "http://localhost:4000";
+    console.log(chalk.gray(`\n🔌 Connected to server events stream (${serverUrl})`));
+    const stopListening = listenToServerEvents({
+        serverUrl,
+        onSchemaUpdated: async () => {
+            // Regenerate types when schema is updated on server
+            try {
+                const analysis = await analyzer.analyze();
+                await generator.generate(analysis);
+                previousAnalysis = analysis;
+                console.log(chalk.green("✅ Types regenerated from server schema"));
+            }
+            catch (error) {
+                console.error(chalk.red("Failed to regenerate types:"), error);
+            }
+        },
+        onDeploymentComplete: (type) => {
+            console.log(chalk.blue(`\n✨ Server deployment complete (${type})`));
+        },
+        onError: (error) => {
+            // Silently ignore connection errors, will retry
+        },
+    });
+    // Handle graceful shutdown
+    process.on("SIGINT", () => {
+        console.log(chalk.yellow("\n\n👋 Shutting down..."));
+        watcher.stop();
+        stopListening();
+        process.exit(0);
+    });
+}

package/dist/commands/generate.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+/**
+ * Generate command with CRUD subcommand
+ */
+export declare const generateCommand: Command;
+//# sourceMappingURL=generate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/commands/generate.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA8GpC;;GAEG;AACH,eAAO,MAAM,eAAe,SASU,CAAC"}