@positronic/cli 0.0.2 → 0.0.4

package/dist/src/commands/helpers.test.js

@@ -1,832 +0,0 @@
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-        var info = gen[key](arg);
-        var value = info.value;
-    } catch (error) {
-        reject(error);
-        return;
-    }
-    if (info.done) {
-        resolve(value);
-    } else {
-        Promise.resolve(value).then(_next, _throw);
-    }
-}
-function _async_to_generator(fn) {
-    return function() {
-        var self = this, args = arguments;
-        return new Promise(function(resolve, reject) {
-            var gen = fn.apply(self, args);
-            function _next(value) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-            }
-            function _throw(err) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-            }
-            _next(undefined);
-        });
-    };
-}
-function _instanceof(left, right) {
-    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-        return !!right[Symbol.hasInstance](left);
-    } else {
-        return left instanceof right;
-    }
-}
-function _ts_generator(thisArg, body) {
-    var f, y, t, _ = {
-        label: 0,
-        sent: function() {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
-        return this;
-    }), g;
-    function verb(n) {
-        return function(v) {
-            return step([
-                n,
-                v
-            ]);
-        };
-    }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while(g && (g = 0, op[0] && (_ = 0)), _)try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [
-                op[0] & 2,
-                t.value
-            ];
-            switch(op[0]){
-                case 0:
-                case 1:
-                    t = op;
-                    break;
-                case 4:
-                    _.label++;
-                    return {
-                        value: op[1],
-                        done: false
-                    };
-                case 5:
-                    _.label++;
-                    y = op[1];
-                    op = [
-                        0
-                    ];
-                    continue;
-                case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                        _ = 0;
-                        continue;
-                    }
-                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                        _.label = op[1];
-                        break;
-                    }
-                    if (op[0] === 6 && _.label < t[1]) {
-                        _.label = t[1];
-                        t = op;
-                        break;
-                    }
-                    if (t && _.label < t[2]) {
-                        _.label = t[2];
-                        _.ops.push(op);
-                        break;
-                    }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) {
-            op = [
-                6,
-                e
-            ];
-            y = 0;
-        } finally{
-            f = t = 0;
-        }
-        if (op[0] & 5) throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
-    }
-}
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { Response } from 'node-fetch';
-import { syncResources, generateTypes } from './helpers.js';
-import { createMockApiClient } from '../test/mock-api-client.js';
-describe('Helper Functions Unit Tests', function() {
-    var tempDir;
-    var projectPath;
-    var mockClient;
-    beforeEach(function() {
-        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'positronic-unit-test-'));
-        projectPath = path.join(tempDir, 'test-project');
-        fs.mkdirSync(projectPath, {
-            recursive: true
-        });
-        mockClient = createMockApiClient();
-    });
-    afterEach(function() {
-        fs.rmSync(tempDir, {
-            recursive: true,
-            force: true
-        });
-        mockClient.reset();
-    });
-    describe('syncResources', function() {
-        it('should create resources directory if it does not exist', function() {
-            return _async_to_generator(function() {
-                var resourcesDir;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            resourcesDir = path.join(projectPath, 'resources');
-                            expect(fs.existsSync(resourcesDir)).toBe(false);
-                            return [
-                                4,
-                                syncResources(projectPath, mockClient)
-                            ];
-                        case 1:
-                            _state.sent();
-                            expect(fs.existsSync(resourcesDir)).toBe(true);
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should return zero counts for empty resources directory', function() {
-            return _async_to_generator(function() {
-                var resourcesDir, result;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            resourcesDir = path.join(projectPath, 'resources');
-                            fs.mkdirSync(resourcesDir, {
-                                recursive: true
-                            });
-                            return [
-                                4,
-                                syncResources(projectPath, mockClient)
-                            ];
-                        case 1:
-                            result = _state.sent();
-                            expect(result).toEqual({
-                                uploadCount: 0,
-                                skipCount: 0,
-                                errorCount: 0,
-                                totalCount: 0,
-                                deleteCount: 0,
-                                errors: []
-                            });
-                            // Should not make any API calls for empty directory
-                            expect(mockClient.calls.length).toBe(1); // Only GET /resources call
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should upload new resources', function() {
-            return _async_to_generator(function() {
-                var _mockClient_calls__options, resourcesDir, result, resources;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            resourcesDir = path.join(projectPath, 'resources');
-                            fs.mkdirSync(resourcesDir, {
-                                recursive: true
-                            });
-                            // Create test files
-                            fs.writeFileSync(path.join(resourcesDir, 'test.txt'), 'Hello World');
-                            fs.writeFileSync(path.join(resourcesDir, 'data.json'), '{"key": "value"}');
-                            return [
-                                4,
-                                syncResources(projectPath, mockClient)
-                            ];
-                        case 1:
-                            result = _state.sent();
-                            expect(result.uploadCount).toBe(2);
-                            expect(result.skipCount).toBe(0);
-                            expect(result.errorCount).toBe(0);
-                            expect(result.totalCount).toBe(2);
-                            // Verify API calls
-                            expect(mockClient.calls).toHaveLength(3); // 1 GET + 2 POSTs
-                            expect(mockClient.calls[0].path).toBe('/resources');
-                            expect(mockClient.calls[1].path).toBe('/resources');
-                            expect((_mockClient_calls__options = mockClient.calls[1].options) === null || _mockClient_calls__options === void 0 ? void 0 : _mockClient_calls__options.method).toBe('POST');
-                            // Verify uploaded resources
-                            resources = mockClient.getResources();
-                            expect(resources).toHaveLength(2);
-                            expect(resources.find(function(r) {
-                                return r.key === 'test.txt';
-                            })).toBeDefined();
-                            expect(resources.find(function(r) {
-                                return r.key === 'data.json';
-                            })).toBeDefined();
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should skip unchanged resources', function() {
-            return _async_to_generator(function() {
-                var resourcesDir, result;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            resourcesDir = path.join(projectPath, 'resources');
-                            fs.mkdirSync(resourcesDir, {
-                                recursive: true
-                            });
-                            // Add existing resource to mock with future lastModified to ensure it's newer than the file
-                            mockClient.addResource({
-                                key: 'existing.txt',
-                                type: 'text',
-                                size: 8,
-                                lastModified: new Date(Date.now() + 10000).toISOString(),
-                                local: false
-                            });
-                            // Create matching file
-                            fs.writeFileSync(path.join(resourcesDir, 'existing.txt'), '12345678'); // 8 bytes
-                            return [
-                                4,
-                                syncResources(projectPath, mockClient)
-                            ];
-                        case 1:
-                            result = _state.sent();
-                            expect(result.uploadCount).toBe(0);
-                            expect(result.skipCount).toBe(1);
-                            expect(result.errorCount).toBe(0);
-                            // Should only make GET call
-                            expect(mockClient.calls).toHaveLength(1);
-                            expect(mockClient.calls[0].path).toBe('/resources');
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should upload modified resources based on size', function() {
-            return _async_to_generator(function() {
-                var resourcesDir, result;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            resourcesDir = path.join(projectPath, 'resources');
-                            fs.mkdirSync(resourcesDir, {
-                                recursive: true
-                            });
-                            // Add existing resource to mock with different size
-                            mockClient.addResource({
-                                key: 'modified.txt',
-                                type: 'text',
-                                size: 5,
-                                lastModified: new Date(Date.now() - 10000).toISOString(),
-                                local: false
-                            });
-                            // Create file with different content
-                            fs.writeFileSync(path.join(resourcesDir, 'modified.txt'), 'New content');
-                            return [
-                                4,
-                                syncResources(projectPath, mockClient)
-                            ];
-                        case 1:
-                            result = _state.sent();
-                            expect(result.uploadCount).toBe(1);
-                            expect(result.skipCount).toBe(0);
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should upload resources based on modification time when size matches', function() {
-            return _async_to_generator(function() {
-                var resourcesDir, result;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            resourcesDir = path.join(projectPath, 'resources');
-                            fs.mkdirSync(resourcesDir, {
-                                recursive: true
-                            });
-                            // Add existing resource to mock with same size but older timestamp
-                            mockClient.addResource({
-                                key: 'updated.txt',
-                                type: 'text',
-                                size: 11,
-                                lastModified: new Date(Date.now() - 10000).toISOString(),
-                                local: false
-                            });
-                            // Create file with same size but it will have a newer modification time
-                            fs.writeFileSync(path.join(resourcesDir, 'updated.txt'), 'Same content'); // 11 bytes
-                            return [
-                                4,
-                                syncResources(projectPath, mockClient)
-                            ];
-                        case 1:
-                            result = _state.sent();
-                            expect(result.uploadCount).toBe(1);
-                            expect(result.skipCount).toBe(0);
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should handle nested directories', function() {
-            return _async_to_generator(function() {
-                var resourcesDir, docsDir, result, resources;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            resourcesDir = path.join(projectPath, 'resources');
-                            docsDir = path.join(resourcesDir, 'docs');
-                            fs.mkdirSync(docsDir, {
-                                recursive: true
-                            });
-                            fs.writeFileSync(path.join(docsDir, 'readme.md'), '# README');
-                            return [
-                                4,
-                                syncResources(projectPath, mockClient)
-                            ];
-                        case 1:
-                            result = _state.sent();
-                            expect(result.uploadCount).toBe(1);
-                            resources = mockClient.getResources();
-                            expect(resources[0].key).toBe('docs/readme.md');
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should handle upload errors gracefully', function() {
-            return _async_to_generator(function() {
-                var resourcesDir, badClient, originalFetch, result;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            resourcesDir = path.join(projectPath, 'resources');
-                            fs.mkdirSync(resourcesDir, {
-                                recursive: true
-                            });
-                            // Create a file that will trigger an error in our mock
-                            // We'll modify the mock to fail on specific file names
-                            badClient = createMockApiClient();
-                            originalFetch = badClient.fetch;
-                            badClient.fetch = function(path, options) {
-                                return _async_to_generator(function() {
-                                    return _ts_generator(this, function(_state) {
-                                        if ((options === null || options === void 0 ? void 0 : options.method) === 'POST' && _instanceof(options.body, FormData) && options.body.get('key') === 'error.txt') {
-                                            throw new Error('Upload failed');
-                                        }
-                                        return [
-                                            2,
-                                            originalFetch.call(badClient, path, options)
-                                        ];
-                                    });
-                                })();
-                            };
-                            fs.writeFileSync(path.join(resourcesDir, 'error.txt'), 'This will fail');
-                            fs.writeFileSync(path.join(resourcesDir, 'good.txt'), 'This will succeed');
-                            return [
-                                4,
-                                syncResources(projectPath, badClient)
-                            ];
-                        case 1:
-                            result = _state.sent();
-                            expect(result.uploadCount).toBe(1);
-                            expect(result.errorCount).toBe(1);
-                            expect(result.errors).toHaveLength(1);
-                            expect(result.errors[0]).toEqual({
-                                file: 'error.txt',
-                                message: 'Upload failed'
-                            });
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should delete server resources with local=true when files are removed', function() {
-            return _async_to_generator(function() {
-                var resourcesDir, result, remainingResources, deleteCalls;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            resourcesDir = path.join(projectPath, 'resources');
-                            fs.mkdirSync(resourcesDir, {
-                                recursive: true
-                            });
-                            // Create the file that should still exist first
-                            fs.writeFileSync(path.join(resourcesDir, 'still-exists.txt'), 'I still exist');
-                            // Add existing resources to mock - some synced (local=true), some manual (local=false)
-                            mockClient.addResource({
-                                key: 'deleted-file.txt',
-                                type: 'text',
-                                size: 100,
-                                lastModified: new Date().toISOString(),
-                                local: true
-                            });
-                            mockClient.addResource({
-                                key: 'still-exists.txt',
-                                type: 'text',
-                                size: 13,
-                                lastModified: new Date(Date.now() + 10000).toISOString(),
-                                local: true
-                            });
-                            mockClient.addResource({
-                                key: 'docs/removed-doc.md',
-                                type: 'text',
-                                size: 200,
-                                lastModified: new Date().toISOString(),
-                                local: true
-                            });
-                            return [
-                                4,
-                                syncResources(projectPath, mockClient)
-                            ];
-                        case 1:
-                            result = _state.sent();
-                            expect(result.deleteCount).toBe(2);
-                            expect(result.uploadCount).toBe(0); // No new uploads
-                            expect(result.skipCount).toBe(1); // still-exists.txt is up to date
-                            // Verify the correct resources were deleted
-                            remainingResources = mockClient.getResources();
-                            expect(remainingResources).toHaveLength(1);
-                            expect(remainingResources[0].key).toBe('still-exists.txt');
-                            // Verify DELETE API calls were made
-                            deleteCalls = mockClient.calls.filter(function(call) {
-                                var _call_options;
-                                return ((_call_options = call.options) === null || _call_options === void 0 ? void 0 : _call_options.method) === 'DELETE';
-                            });
-                            expect(deleteCalls).toHaveLength(2);
-                            expect(deleteCalls[0].path).toBe('/resources/deleted-file.txt');
-                            expect(deleteCalls[1].path).toBe('/resources/docs%2Fremoved-doc.md'); // URL encoded
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should preserve manually uploaded resources (local=false)', function() {
-            return _async_to_generator(function() {
-                var resourcesDir, result, remainingResources, deleteCalls;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            resourcesDir = path.join(projectPath, 'resources');
-                            fs.mkdirSync(resourcesDir, {
-                                recursive: true
-                            });
-                            // Add existing resources to mock
-                            mockClient.addResource({
-                                key: 'manual-upload.txt',
-                                type: 'text',
-                                size: 100,
-                                lastModified: new Date().toISOString(),
-                                local: false
-                            });
-                            mockClient.addResource({
-                                key: 'another-manual.png',
-                                type: 'binary',
-                                size: 5000,
-                                lastModified: new Date().toISOString(),
-                                local: false
-                            });
-                            mockClient.addResource({
-                                key: 'synced-file.txt',
-                                type: 'text',
-                                size: 75,
-                                lastModified: new Date().toISOString(),
-                                local: true
-                            });
-                            return [
-                                4,
-                                syncResources(projectPath, mockClient)
-                            ];
-                        case 1:
-                            result = _state.sent();
-                            expect(result.deleteCount).toBe(1); // Only the synced file
-                            expect(result.uploadCount).toBe(0);
-                            expect(result.skipCount).toBe(0);
-                            // Verify manual uploads are still there
-                            remainingResources = mockClient.getResources();
-                            expect(remainingResources).toHaveLength(2);
-                            expect(remainingResources.find(function(r) {
-                                return r.key === 'manual-upload.txt';
-                            })).toBeDefined();
-                            expect(remainingResources.find(function(r) {
-                                return r.key === 'another-manual.png';
-                            })).toBeDefined();
-                            expect(remainingResources.find(function(r) {
-                                return r.key === 'synced-file.txt';
-                            })).toBeUndefined();
-                            // Verify only one DELETE call was made
-                            deleteCalls = mockClient.calls.filter(function(call) {
-                                var _call_options;
-                                return ((_call_options = call.options) === null || _call_options === void 0 ? void 0 : _call_options.method) === 'DELETE';
-                            });
-                            expect(deleteCalls).toHaveLength(1);
-                            expect(deleteCalls[0].path).toBe('/resources/synced-file.txt');
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should handle delete errors gracefully', function() {
-            return _async_to_generator(function() {
-                var resourcesDir, badClient, originalFetch, result;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            resourcesDir = path.join(projectPath, 'resources');
-                            fs.mkdirSync(resourcesDir, {
-                                recursive: true
-                            });
-                            // Create a client that fails on DELETE requests
-                            badClient = createMockApiClient();
-                            badClient.addResource({
-                                key: 'will-fail-delete.txt',
-                                type: 'text',
-                                size: 100,
-                                lastModified: new Date().toISOString(),
-                                local: true
-                            });
-                            originalFetch = badClient.fetch;
-                            badClient.fetch = function(path, options) {
-                                return _async_to_generator(function() {
-                                    return _ts_generator(this, function(_state) {
-                                        if ((options === null || options === void 0 ? void 0 : options.method) === 'DELETE') {
-                                            return [
-                                                2,
-                                                new Response('Internal Server Error', {
-                                                    status: 500
-                                                })
-                                            ];
-                                        }
-                                        return [
-                                            2,
-                                            originalFetch.call(badClient, path, options)
-                                        ];
-                                    });
-                                })();
-                            };
-                            return [
-                                4,
-                                syncResources(projectPath, badClient)
-                            ];
-                        case 1:
-                            result = _state.sent();
-                            expect(result.deleteCount).toBe(0); // Failed to delete
-                            expect(result.errorCount).toBe(1);
-                            expect(result.errors).toHaveLength(1);
-                            expect(result.errors[0]).toEqual({
-                                file: 'will-fail-delete.txt',
-                                message: 'Failed to delete: Delete failed: 500 Internal Server Error'
-                            });
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-    });
-    describe('generateTypes', function() {
-        it('should generate types file for empty resources', function() {
-            return _async_to_generator(function() {
-                var result, typesPath, content;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            return [
-                                4,
-                                generateTypes(projectPath, mockClient)
-                            ];
-                        case 1:
-                            result = _state.sent();
-                            typesPath = path.join(projectPath, 'resources.d.ts');
-                            expect(fs.existsSync(typesPath)).toBe(true);
-                            content = fs.readFileSync(typesPath, 'utf-8');
-                            expect(content).toContain("declare module '@positronic/core'");
-                            expect(content).toContain('interface Resources');
-                            expect(content).toContain('loadText(path: string): Promise<string>');
-                            expect(content).toContain('loadBinary(path: string): Promise<Buffer>');
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should generate types for text and binary resources', function() {
-            return _async_to_generator(function() {
-                var typesPath, content;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            // Add mock resources
-                            mockClient.addResource({
-                                key: 'readme.md',
-                                type: 'text',
-                                size: 100,
-                                lastModified: new Date().toISOString(),
-                                local: false
-                            });
-                            mockClient.addResource({
-                                key: 'logo.png',
-                                type: 'binary',
-                                size: 1000,
-                                lastModified: new Date().toISOString(),
-                                local: false
-                            });
-                            mockClient.addResource({
-                                key: 'data.json',
-                                type: 'text',
-                                size: 50,
-                                lastModified: new Date().toISOString(),
-                                local: false
-                            });
-                            return [
-                                4,
-                                generateTypes(projectPath, mockClient)
-                            ];
-                        case 1:
-                            _state.sent();
-                            typesPath = path.join(projectPath, 'resources.d.ts');
-                            content = fs.readFileSync(typesPath, 'utf-8');
-                            // Check resource declarations
-                            expect(content).toContain('readme: TextResource;');
-                            expect(content).toContain('logo: BinaryResource;');
-                            expect(content).toContain('data: TextResource;');
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should handle nested resources', function() {
-            return _async_to_generator(function() {
-                var typesPath, content;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            mockClient.addResource({
-                                key: 'docs/api.md',
-                                type: 'text',
-                                size: 100,
-                                lastModified: new Date().toISOString(),
-                                local: false
-                            });
-                            mockClient.addResource({
-                                key: 'docs/images/diagram.png',
-                                type: 'binary',
-                                size: 500,
-                                lastModified: new Date().toISOString(),
-                                local: false
-                            });
-                            mockClient.addResource({
-                                key: 'config/settings.json',
-                                type: 'text',
-                                size: 200,
-                                lastModified: new Date().toISOString(),
-                                local: false
-                            });
-                            return [
-                                4,
-                                generateTypes(projectPath, mockClient)
-                            ];
-                        case 1:
-                            _state.sent();
-                            typesPath = path.join(projectPath, 'resources.d.ts');
-                            content = fs.readFileSync(typesPath, 'utf-8');
-                            // Check nested structure
-                            expect(content).toContain('docs: {');
-                            expect(content).toContain('api: TextResource;');
-                            expect(content).toContain('images: {');
-                            expect(content).toContain('diagram: BinaryResource;');
-                            expect(content).toContain('config: {');
-                            expect(content).toContain('settings: TextResource;');
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should exclude invalid JavaScript identifiers', function() {
-            return _async_to_generator(function() {
-                var typesPath, content;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            mockClient.addResource({
-                                key: '123invalid.txt',
-                                type: 'text',
-                                size: 100,
-                                lastModified: new Date().toISOString(),
-                                local: false
-                            });
-                            mockClient.addResource({
-                                key: 'file-with-dash.txt',
-                                type: 'text',
-                                size: 100,
-                                lastModified: new Date().toISOString(),
-                                local: false
-                            });
-                            mockClient.addResource({
-                                key: 'valid_file.txt',
-                                type: 'text',
-                                size: 100,
-                                lastModified: new Date().toISOString(),
-                                local: false
-                            });
-                            return [
-                                4,
-                                generateTypes(projectPath, mockClient)
-                            ];
-                        case 1:
-                            _state.sent();
-                            typesPath = path.join(projectPath, 'resources.d.ts');
-                            content = fs.readFileSync(typesPath, 'utf-8');
-                            // Should include valid identifier
-                            expect(content).toContain('valid_file: TextResource;');
-                            // Should not include invalid identifiers
-                            expect(content).not.toContain('123invalid');
-                            expect(content).not.toContain('file-with-dash');
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-        it('should handle API errors gracefully', function() {
-            return _async_to_generator(function() {
-                var errorClient;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            // Create a client that returns an error
-                            errorClient = createMockApiClient();
-                            errorClient.fetch = function(path, options) {
-                                return _async_to_generator(function() {
-                                    return _ts_generator(this, function(_state) {
-                                        return [
-                                            2,
-                                            new Response('Internal Server Error', {
-                                                status: 500
-                                            })
-                                        ];
-                                    });
-                                })();
-                            };
-                            return [
-                                4,
-                                expect(generateTypes(projectPath, errorClient)).rejects.toThrow('Failed to fetch resources: 500 Internal Server Error')
-                            ];
-                        case 1:
-                            _state.sent();
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        });
-    });
-});