@adaas/a-frame 0.0.23 → 0.1.2

package/tests/integration/A-FrameNamespace.integration.test.ts

@@ -0,0 +1,109 @@
+/**
+ * A-FrameNamespace.integration.test.ts — integration test for the A_FrameNamespace
+ * embedding round-trip.
+ *
+ * Required env vars:
+ *   A_FRAME_SERVER_URL  — e.g. http://localhost:3000
+ *   A_FRAME_VERSION     — semver of the client library, e.g. 0.1.1
+ */
+
+import { config } from 'dotenv';
+import { A_Concept, A_Container } from '@adaas/a-concept';
+import { A_Frame } from '@adaas/a-frame/core';
+import { A_FrameNamespace } from '@adaas/a-frame/namespace';
+import { A_FrameVector } from '@adaas/a-frame/vector';
+
+config();
+
+jest.setTimeout(60_000);
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+function makeNamespace(description?: string) {
+    return new A_FrameNamespace({
+        name: 'user-management',
+        description: description ?? 'Handles user authentication, registration, profiles, and access-control rules.',
+        metadata: { domain: 'auth' },
+    });
+}
+
+async function setup(...namespaces: A_FrameNamespace[]) {
+    const container = new A_Container({ name: 'test-container', components: [] });
+    const concept = new A_Concept({
+        name: 'Test Concept',
+        components: [A_Frame],
+        containers: [container],
+    });
+    for (const ns of namespaces) {
+        container.scope.register(ns);
+    }
+    await concept.load();
+}
+
+// ─── tests ────────────────────────────────────────────────────────────────────
+
+describe('A-Frame Namespace Tests', () => {
+
+    describe('Integration — embed() round-trip', () => {
+
+        // Single-namespace assertions share one embed() call via beforeAll.
+        describe('single namespace', () => {
+
+            let ns: A_FrameNamespace;
+
+            beforeAll(async () => {
+                ns = makeNamespace();
+                await setup(ns);
+                await ns.embed();
+            });
+
+            it('populates vector after embed()', () => {
+                expect(ns.vector).toBeDefined();
+                expect(ns.vector).toBeInstanceOf(A_FrameVector);
+                expect(ns.vector!.values.length).toBeGreaterThan(0);
+                expect(typeof ns.aFrameServerVersion).toBe('string');
+            });
+
+            it('isEmbed is true after embed()', () => {
+                expect(ns.isEmbed).toBe(true);
+            });
+
+            it('sets provenance metadata (aFrameServerVersion)', () => {
+                expect(ns.aFrameServerVersion).toBeDefined();
+                expect(typeof ns.aFrameServerVersion).toBe('string');
+            });
+
+        });
+
+        it('two namespaces with different names produce different vectors', async () => {
+            const nsA = new A_FrameNamespace({ name: 'finance-domain', description: 'Financial calculations and reporting.' });
+            const nsB = new A_FrameNamespace({ name: 'user-management', description: 'User accounts and access control.' });
+            await setup(nsA, nsB);
+
+            await Promise.all([nsA.embed(), nsB.embed()]);
+
+            expect(nsA.vector).toBeDefined();
+            expect(nsB.vector).toBeDefined();
+            expect(Array.from(nsA.vector!.values)).not.toEqual(Array.from(nsB.vector!.values));
+        });
+
+        it('preserves vector through toJSON / fromJSON round-trip', async () => {
+            const ns = makeNamespace();
+            await setup(ns);
+            await ns.embed();
+
+            const serialized = ns.toJSON();
+            expect(serialized.embedding).toBeDefined();
+            expect(serialized.aFrameServerVersion).toBeDefined();
+
+            const restored = new A_FrameNamespace({ name: 'user-management' });
+            restored.fromJSON(serialized);
+
+            expect(restored.vector).toBeDefined();
+            expect(Array.from(restored.vector!.values)).toEqual(Array.from(ns.vector!.values));
+            expect(restored.aFrameServerVersion).toBe(ns.aFrameServerVersion);
+        });
+
+    });
+
+});

package/tests/integration/A-FrameSchema.integration.test.ts

@@ -0,0 +1,74 @@
+import { A_Concept, A_Container, A_Error } from '@adaas/a-concept';
+import { A_Frame } from '@adaas/a-frame/core';
+import { config } from 'dotenv';
+import { A_FrameSchema } from '@adaas/a-frame/schema';
+import { A_FRAME_MODELS } from '@adaas/a-frame/models';
+
+config();
+
+jest.setTimeout(60_000);
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+async function buildConcept() {
+    const container = new A_Container({
+        name: 'Schema Test Container',
+        components: [],
+    });
+    const concept = new A_Concept({
+        name: 'Test Concept',
+        components: [A_Frame],
+        containers: [container],
+    });
+    await concept.load();
+    return { concept, container };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('A-Frame Schema Tests', () => {
+
+    describe('Integration — structured extraction', () => {
+
+        let container: A_Container;
+
+        beforeEach(async () => {
+            ({ container } = await buildConcept());
+        });
+
+        it('extracts structured data from a natural-language prompt', async () => {
+            try {
+                type FlightParams = { destination: string; date: string };
+
+                const schema = new A_FrameSchema<FlightParams>({
+                    prompt: 'I need to fly to Berlin next Friday.',
+                    schema: {
+                        destination: 'string - the city the user wants to fly to',
+                        date: 'string - the travel date or relative day',
+                    } as Record<keyof FlightParams, string>,
+                });
+
+                expect(schema.options?.model).toBe(A_FRAME_MODELS.NOVA);
+                expect(schema.isExtracted).toBe(false);
+
+                container.scope.register(schema);
+                await schema.extract();
+
+                expect(schema.isExtracted).toBe(true);
+                expect(schema.data).toBeDefined();
+                expect(typeof schema.data!.destination).toBe('string');
+                expect(schema.data!.destination.length).toBeGreaterThan(0);
+                expect(typeof schema.data!.date).toBe('string');
+                expect(schema.data!.date.length).toBeGreaterThan(0);
+                expect(typeof schema.model).toBe('string');
+                expect(schema.model!.length).toBeGreaterThan(0);
+            } catch (error) {
+                if (error instanceof A_Error) console.error('A_Error:', error.toJSON());
+                else console.error('Unexpected error:', error);
+                throw error;
+            }
+        });
+
+    });
+
+});

package/tests/integration/A-FrameSegment.integration.test.ts

@@ -0,0 +1,102 @@
+import { A_Concept, A_Container, A_Error } from '@adaas/a-concept';
+import { A_Frame } from '@adaas/a-frame/core';
+import { config } from 'dotenv';
+import { A_FrameSegment } from '@adaas/a-frame/segment';
+import { A_FRAME_MODELS } from '@adaas/a-frame/models';
+
+config();
+
+jest.setTimeout(60_000);
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+async function buildConcept() {
+    const container = new A_Container({ name: 'Segment Test Container', components: [] });
+    const concept = new A_Concept({
+        name: 'Test Concept',
+        components: [A_Frame],
+        containers: [container],
+    });
+    await concept.load();
+    return { concept, container };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('A-Frame Segment Tests', () => {
+
+    describe('Integration — embedding round-trip', () => {
+
+        let container: A_Container;
+
+        beforeEach(async () => {
+            ({ container } = await buildConcept());
+        });
+
+        it('produces a non-empty vector after embed()', async () => {
+            try {
+                const segment = new A_FrameSegment({
+                    content: 'The quick brown fox jumps over the lazy dog.',
+                });
+                expect(segment.options?.model).toBe(A_FRAME_MODELS.ANTARES);
+                container.scope.register(segment);
+                await segment.embed();
+
+                expect(segment.vector).toBeDefined();
+                expect(segment.vector!.values.length).toBeGreaterThan(0);
+            } catch (error) {
+                if (error instanceof A_Error) console.error('A_Error:', error.toJSON());
+                else console.error('Unexpected error:', error);
+                throw error;
+            }
+        });
+
+        it('same content produces equal vectors', async () => {
+            try {
+                const seg1 = new A_FrameSegment({
+                    content: 'The quick brown fox jumps over the lazy dog.',
+                });
+                const seg2 = new A_FrameSegment({
+                    content: 'The quick brown fox jumps over the lazy dog.',
+                });
+                container.scope.register(seg1);
+                container.scope.register(seg2);
+                await seg1.embed();
+                await seg2.embed();
+
+                expect(seg1.vector).toBeDefined();
+                expect(seg2.vector).toBeDefined();
+                expect(seg2.vector!.isEqualTo(seg1.vector!)).toBe(true);
+            } catch (error) {
+                if (error instanceof A_Error) console.error('A_Error:', error.toJSON());
+                else console.error('Unexpected error:', error);
+                throw error;
+            }
+        });
+
+        it('different content produces different vectors', async () => {
+            try {
+                const seg1 = new A_FrameSegment({
+                    content: 'The quick brown fox jumps over the lazy dog.',
+                });
+                const seg3 = new A_FrameSegment({
+                    content: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
+                });
+                container.scope.register(seg1);
+                container.scope.register(seg3);
+                await seg1.embed();
+                await seg3.embed();
+
+                expect(seg1.vector).toBeDefined();
+                expect(seg3.vector).toBeDefined();
+                expect(seg3.vector!.isEqualTo(seg1.vector!)).toBe(false);
+            } catch (error) {
+                if (error instanceof A_Error) console.error('A_Error:', error.toJSON());
+                else console.error('Unexpected error:', error);
+                throw error;
+            }
+        });
+
+    });
+
+});