@positronic/core 0.0.1 → 0.0.2

package/test/resources.test.ts

@@ -0,0 +1,248 @@
+import { createResources, type Manifest } from '../src/resources/resources.js';
+import { ResourceLoader } from '../src/resources/resource-loader.js';
+
+// Mock loader for testing
+class MockLoader implements ResourceLoader {
+  private mockData: Record<string, string | Buffer> = {
+    'example.md': 'Example content',
+    'my file with spaces.txt': 'Content with spaces in filename',
+    'data/2024-report.pdf': Buffer.from('Mock PDF content'),
+    'docs/readme.md': 'Documentation content',
+    'special-chars!@#.txt': 'Special characters content',
+  };
+
+  addMockData(path: string, content: string | Buffer): void {
+    this.mockData[path] = content;
+  }
+
+  async load(key: string, type: 'text'): Promise<string>;
+  async load(key: string, type: 'binary'): Promise<Buffer>;
+  async load(key: string, type: 'text' | 'binary'): Promise<string | Buffer> {
+    const data = this.mockData[key];
+    if (!data) {
+      throw new Error(`Resource not found: ${key}`);
+    }
+
+    if (type === 'text' && Buffer.isBuffer(data)) {
+      return data.toString();
+    }
+    if (type === 'binary' && typeof data === 'string') {
+      return Buffer.from(data);
+    }
+
+    return data;
+  }
+}
+
+describe('Resources API', () => {
+  let resources: any;
+
+  beforeEach(() => {
+    const manifest: Manifest = {
+      'example.md': {
+        type: 'text',
+        path: 'example.md',
+        key: 'example.md',
+      },
+      'my file with spaces.txt': {
+        type: 'text',
+        path: 'my file with spaces.txt',
+        key: 'my file with spaces.txt',
+      },
+      data: {
+        '2024-report.pdf': {
+          type: 'binary',
+          path: 'data/2024-report.pdf',
+          key: 'data/2024-report.pdf',
+        },
+      },
+      docs: {
+        'readme.md': {
+          type: 'text',
+          path: 'docs/readme.md',
+          key: 'docs/readme.md',
+        },
+      },
+      'special-chars!@#.txt': {
+        type: 'text',
+        path: 'special-chars!@#.txt',
+        key: 'special-chars!@#.txt',
+      },
+    };
+
+    const loader = new MockLoader();
+    resources = createResources(loader, manifest);
+  });
+
+  describe('Proxy API (for JS-identifier compatible names)', () => {
+    it('should load simple resource via proxy', async () => {
+      const content = await resources.example.loadText();
+      expect(content).toBe('Example content');
+    });
+
+    it('should load nested resource via proxy', async () => {
+      const content = await resources.docs.readme.loadText();
+      expect(content).toBe('Documentation content');
+    });
+
+    it('should load binary resource via proxy', async () => {
+      const buffer = await resources.data['2024-report.pdf'].loadBinary();
+      expect(buffer.toString()).toBe('Mock PDF content');
+    });
+  });
+
+  describe('Method API (for any filename)', () => {
+    it('should load resource with spaces in name', async () => {
+      const content = await resources.loadText('my file with spaces.txt');
+      expect(content).toBe('Content with spaces in filename');
+    });
+
+    it('should load nested resource by path', async () => {
+      const content = await resources.loadText('docs/readme.md');
+      expect(content).toBe('Documentation content');
+    });
+
+    it('should load binary resource by path', async () => {
+      const buffer = await resources.loadBinary('data/2024-report.pdf');
+      expect(buffer.toString()).toBe('Mock PDF content');
+    });
+
+    it('should load resource with special characters', async () => {
+      const content = await resources.loadText('special-chars!@#.txt');
+      expect(content).toBe('Special characters content');
+    });
+
+    it('should throw error for non-existent resource', async () => {
+      await expect(resources.loadText('non-existent.txt')).rejects.toThrow(
+        'Resource not found: non-existent.txt'
+      );
+    });
+
+    it('should throw error when using wrong type method', async () => {
+      await expect(resources.loadText('data/2024-report.pdf')).rejects.toThrow(
+        'Resource "data/2024-report.pdf" is of type "binary", but was accessed with loadText()'
+      );
+
+      await expect(resources.loadBinary('example.md')).rejects.toThrow(
+        'Resource "example.md" is of type "text", but was accessed with loadBinary()'
+      );
+    });
+  });
+
+  describe('Mixed usage', () => {
+    it('should support both APIs in the same brain', async () => {
+      // Use proxy API for clean names
+      const example = await resources.example.loadText();
+
+      // Use method API for names with spaces
+      const withSpaces = await resources.loadText('my file with spaces.txt');
+
+      // Both should work
+      expect(example).toBe('Example content');
+      expect(withSpaces).toBe('Content with spaces in filename');
+    });
+  });
+
+  describe('Ambiguous resource names', () => {
+    let ambiguousResources: any;
+
+    beforeEach(() => {
+      const ambiguousManifest: Manifest = {
+        'example.md': {
+          type: 'text',
+          path: 'example.md',
+          key: 'example.md',
+        },
+        'example.txt': {
+          type: 'text',
+          path: 'example.txt',
+          key: 'example.txt',
+        },
+        'report.pdf': {
+          type: 'binary',
+          path: 'report.pdf',
+          key: 'report.pdf',
+        },
+        'report.docx': {
+          type: 'binary',
+          path: 'report.docx',
+          key: 'report.docx',
+        },
+        nested: {
+          'config.json': {
+            type: 'text',
+            path: 'nested/config.json',
+            key: 'nested/config.json',
+          },
+          'config.yaml': {
+            type: 'text',
+            path: 'nested/config.yaml',
+            key: 'nested/config.yaml',
+          },
+        },
+      };
+
+      const mockLoader = new MockLoader();
+      // Add the ambiguous files to mock data
+      mockLoader.addMockData('example.md', 'Example markdown content');
+      mockLoader.addMockData('example.txt', 'Example text content');
+      mockLoader.addMockData('report.pdf', Buffer.from('PDF content'));
+      mockLoader.addMockData('report.docx', Buffer.from('DOCX content'));
+      mockLoader.addMockData('nested/config.json', '{"config": "json"}');
+      mockLoader.addMockData('nested/config.yaml', 'config: yaml');
+
+      ambiguousResources = createResources(mockLoader, ambiguousManifest);
+    });
+
+    it('should throw error when accessing ambiguous resource via proxy', () => {
+      expect(() => ambiguousResources.example).toThrow(
+        "Ambiguous resource name 'example': found example.md, example.txt. " +
+          "Please use resources.loadText('example.md') or resources.loadBinary('example.txt') instead."
+      );
+    });
+
+    it('should throw error for ambiguous binary resources', () => {
+      expect(() => ambiguousResources.report).toThrow(
+        "Ambiguous resource name 'report': found report.pdf, report.docx"
+      );
+    });
+
+    it('should throw error for ambiguous nested resources', () => {
+      expect(() => ambiguousResources.nested.config).toThrow(
+        "Ambiguous resource name 'config': found config.json, config.yaml"
+      );
+    });
+
+    it('should allow direct access with full filename', async () => {
+      const markdownContent = await ambiguousResources['example.md'].loadText();
+      const textContent = await ambiguousResources['example.txt'].loadText();
+
+      expect(markdownContent).toBe('Example markdown content');
+      expect(textContent).toBe('Example text content');
+    });
+
+    it('should work with method API for ambiguous resources', async () => {
+      const markdownContent = await ambiguousResources.loadText('example.md');
+      const textContent = await ambiguousResources.loadText('example.txt');
+
+      expect(markdownContent).toBe('Example markdown content');
+      expect(textContent).toBe('Example text content');
+    });
+
+    it('should handle ambiguous paths in loadText/loadBinary methods', async () => {
+      // Should work with full path
+      const jsonContent = await ambiguousResources.loadText(
+        'nested/config.json'
+      );
+      expect(jsonContent).toBe('{"config": "json"}');
+
+      // Should throw error for ambiguous path without extension
+      await expect(
+        ambiguousResources.loadText('nested/config')
+      ).rejects.toThrow(
+        "Ambiguous resource path 'nested/config': found config.json, config.yaml. " +
+          'Please specify the full filename with extension.'
+      );
+    });
+  });
+});

package/tsconfig.json

@@ -3,8 +3,8 @@
   "compilerOptions": {
     "rootDir": "./src",
     "emitDeclarationOnly": true,
-    "declarationDir": "./dist/types",
+    "declarationDir": "./dist/types"
   },
   "include": ["src/**/*"],
   "exclude": ["dist", "node_modules", "**/*.test.ts"]
-}
+}

package/.swcrc

@@ -1,31 +0,0 @@
-{
-  "jsc": {
-    "parser": {
-      "syntax": "typescript"
-    },
-    "target": "es2022",
-    "experimental": {
-      "plugins": [
-        [
-          "@swc/plugin-transform-imports",
-          {
-            "^(\\.{1,2}\\/.*?)$": {
-              "skipDefaultConversion": true,
-              "transform": "{{matches.[1]}}.js"
-            }
-          }
-        ]
-      ]
-    }
-  },
-  "module": {
-    "type": "es6"
-  },
-  "exclude": [
-    ".*\\.test\\.ts$",
-    "node_modules",
-    "dist",
-    "coverage",
-    "jest.config.*"
-  ]
-}

package/dist/src/dsl/extensions.js

@@ -1,19 +0,0 @@
-import { Workflow } from "./workflow.js";
-export function createExtension(key, extension) {
-    return {
-        install () {
-            Object.defineProperty(Workflow.prototype, key, {
-                get () {
-                    const boundMethods = {};
-                    for (const [methodKey, fn] of Object.entries(extension)){
-                        boundMethods[methodKey] = fn.bind(this);
-                    }
-                    return boundMethods;
-                }
-            });
-        },
-        augment () {
-            return {};
-        }
-    };
-}

package/dist/src/dsl/workflow-runner.js

@@ -1,93 +0,0 @@
-import { WORKFLOW_EVENTS } from "./constants.js";
-import { applyPatches } from "./json-patch.js";
-export class WorkflowRunner {
-    options;
-    constructor(options){
-        this.options = options;
-    }
-    async run(workflow, { initialState = {}, options, initialCompletedSteps, workflowRunId, endAfter } = {}) {
-        const { adapters, logger: { log }, verbose, fileStore, client } = this.options;
-        let currentState = initialState ?? {};
-        let stepNumber = 1;
-        // Apply any patches from completed steps
-        // to the initial state so that the workflow
-        // starts with a state that reflects all of the completed steps.
-        // Need to do this when a workflow is restarted with completed steps.
-        initialCompletedSteps?.forEach((step)=>{
-            if (step.patch) {
-                currentState = applyPatches(currentState, [
-                    step.patch
-                ]);
-                stepNumber++;
-            }
-        });
-        const workflowRun = workflowRunId && initialCompletedSteps ? workflow.run({
-            initialState,
-            initialCompletedSteps,
-            workflowRunId,
-            options,
-            client,
-            fileStore
-        }) : workflow.run({
-            initialState,
-            options,
-            client,
-            fileStore
-        });
-        for await (const event of workflowRun){
-            // Dispatch event to all adapters
-            await Promise.all(adapters.map((adapter)=>adapter.dispatch(event)));
-            // Update current state when steps complete
-            if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE) {
-                if (event.patch) {
-                    currentState = applyPatches(currentState, [
-                        event.patch
-                    ]);
-                }
-                // Check if we should stop after this step
-                if (endAfter && stepNumber >= endAfter) {
-                    // Log final state if verbose
-                    if (verbose) {
-                        log(`\nWorkflow stopped after step ${endAfter} as requested: \n\n ${JSON.stringify(this.truncateDeep(structuredClone(currentState)), null, 2)}`);
-                    }
-                    return;
-                }
-                stepNumber++;
-            }
-            // Log final state on workflow completion/error if verbose
-            if ((event.type === WORKFLOW_EVENTS.COMPLETE || event.type === WORKFLOW_EVENTS.ERROR) && verbose) {
-                log(`\nWorkflow completed: \n\n ${JSON.stringify(this.truncateDeep(structuredClone(currentState)), null, 2)}`);
-            }
-        }
-    }
-    truncateDeep(obj, maxLength = 100) {
-        if (obj === null || obj === undefined) return obj;
-        if (typeof obj === 'string') {
-            return obj.length > maxLength ? obj.slice(0, maxLength) + '...' : obj;
-        }
-        if (Array.isArray(obj)) {
-            if (obj.length === 0) return obj;
-            let truncatedArray = [];
-            let currentLength = 2; // Account for [] brackets
-            for(let i = 0; i < obj.length; i++){
-                const processedItem = this.truncateDeep(obj[i], maxLength);
-                const itemStr = JSON.stringify(processedItem);
-                if (currentLength + itemStr.length + (i > 0 ? 1 : 0) > maxLength) {
-                    truncatedArray.push(`... (${obj.length})`);
-                    break;
-                }
-                truncatedArray.push(processedItem);
-                currentLength += itemStr.length + (i > 0 ? 1 : 0); // Add 1 for comma
-            }
-            return truncatedArray;
-        }
-        if (typeof obj === 'object') {
-            const truncated = {};
-            for (const [key, value] of Object.entries(obj)){
-                truncated[key] = this.truncateDeep(value, maxLength);
-            }
-            return truncated;
-        }
-        return obj;
-    }
-}