@timeback/powerpath 0.1.1

package/README.md

@@ -0,0 +1,138 @@
+# @timeback/powerpath
+
+PowerPath SDK for placement tests, lesson plans, and assessment workflows.
+
+## Installation
+
+```bash
+bun add @timeback/powerpath
+```
+
+## Quick Start
+
+```typescript
+import { PowerPathClient } from '@timeback/powerpath'
+
+const client = new PowerPathClient({
+	env: 'staging',
+	auth: { clientId: 'your-client-id', clientSecret: 'your-client-secret' },
+})
+
+const { lessonPlanId } = await client.lessonPlans.create({
+	courseId: 'course-123',
+	userId: 'teacher-456',
+})
+```
+
+## API Design
+
+### Standalone vs Composed
+
+```typescript
+// Composed
+import { TimebackClient } from '@timeback/core'
+
+// Standalone
+const powerpath = new PowerPathClient({ env: 'staging', auth })
+
+const client = new TimebackClient({ env: 'staging', auth })
+client.powerpath.lessonPlans.create({ courseId, userId })
+```
+
+### Client Structure
+
+```typescript
+const client = new PowerPathClient(options)
+
+client.assessments // Tests, attempts, and responses
+client.lessonPlans // Course lesson plans and progress
+client.placement // Placement testing
+client.screening // MAP test sessions
+client.syllabus // Course structure
+client.testAssignments // Test assignment CRUD
+```
+
+### Typed Responses
+
+All methods return typed responses:
+
+```typescript
+import type { ExternalTestCreateResponse, GetNextPlacementTestResponse } from '@timeback/powerpath'
+
+// Create a test - returns { lessonId, resourceId }
+const test: ExternalTestCreateResponse = await client.assessments.createExternalTestOut({
+	courseId: 'course-123',
+	lessonType: 'test-out',
+	toolProvider: 'mastery-track',
+	grades: [3],
+	xp: 10,
+	resourceMetadata: { subject: 'Math' },
+})
+console.log(test.lessonId, test.resourceId)
+
+// Get next placement test - returns { availableTests, lesson }
+const next: GetNextPlacementTestResponse = await client.placement.getNextPlacementTest({
+	student: 'student-123',
+	subject: 'Math',
+})
+console.log(`${next.availableTests} tests available, next: ${next.lesson}`)
+```
+
+## Configuration
+
+```typescript
+new PowerPathClient({
+	// Environment mode (recommended for Timeback APIs)
+	env: 'staging' | 'production',
+	auth: {
+		clientId: string,
+		clientSecret: string,
+	},
+
+	// OR explicit mode (custom API)
+	baseUrl: string,
+	auth: {
+		clientId: string,
+		clientSecret: string,
+		authUrl: string,
+	},
+
+	// OR provider mode (shared auth across clients)
+	provider: TimebackProvider,
+
+	// Optional
+	timeout?: number, // Request timeout in ms (default: 30000)
+})
+```
+
+Environment variables fallback:
+
+- `POWERPATH_BASE_URL`
+- `POWERPATH_TOKEN_URL`
+- `POWERPATH_CLIENT_ID`
+- `POWERPATH_CLIENT_SECRET`
+
+## Debug Mode
+
+Enable debug logging by setting `DEBUG=1` or `DEBUG=true`:
+
+```bash
+DEBUG=1 bun run my-script.ts
+```
+
+## Error Handling
+
+```typescript
+import { NotFoundError, PowerPathError } from '@timeback/powerpath/errors'
+
+try {
+	await client.testAssignments.get('missing-id')
+} catch (error) {
+	if (error instanceof NotFoundError) {
+		console.log('Assignment not found')
+	} else if (error instanceof PowerPathError) {
+		console.log(error.statusCode)
+		console.log(error.message)
+	}
+}
+```

package/dist/client.d.ts

@@ -0,0 +1,70 @@
+/**
+ * PowerPath Client
+ *
+ * Main entry point for the PowerPath SDK.
+ */
+/**
+ * PowerPath API client for adaptive learning workflows.
+ *
+ * Provides access to PowerPath endpoints including placement testing,
+ * lesson plans, assessment flow, screening sessions, and test assignments.
+ *
+ * @example Environment mode (Timeback APIs)
+ * ```typescript
+ * const client = new PowerPathClient({
+ *   env: 'staging', // or 'production'
+ *   auth: {
+ *     clientId: 'your-client-id',
+ *     clientSecret: 'your-client-secret',
+ *   },
+ * })
+ * ```
+ *
+ * @example Provider mode (shared tokens)
+ * ```typescript
+ * import { TimebackProvider } from '@timeback/internal-client-infra'
+ *
+ * const provider = new TimebackProvider({
+ *   platform: 'BEYOND_AI',
+ *   env: 'staging',
+ *   auth: { clientId: '...', clientSecret: '...' },
+ * })
+ *
+ * const client = new PowerPathClient({ provider })
+ * ```
+ *
+ * @example Explicit mode (custom API)
+ * ```typescript
+ * const client = new PowerPathClient({
+ *   baseUrl: 'https://api.example.com',
+ *   auth: {
+ *     clientId: 'your-client-id',
+ *     clientSecret: 'your-client-secret',
+ *     authUrl: 'https://auth.example.com/oauth2/token',
+ *   },
+ * })
+ * ```
+ *
+ * @example Environment variables fallback
+ * ```typescript
+ * // Set POWERPATH_BASE_URL, POWERPATH_TOKEN_URL,
+ * // POWERPATH_CLIENT_ID, POWERPATH_CLIENT_SECRET
+ * const client = new PowerPathClient()
+ * ```
+ */
+export declare const PowerPathClient: {
+    new (config?: import("./types").PowerPathClientConfig): {
+        readonly transport: import("./types").PowerPathTransportLike;
+        readonly _provider?: import("@timeback/internal-client-infra").TimebackProvider | undefined;
+        readonly assessments: import("./resources").AssessmentResource;
+        readonly lessonPlans: import("./resources").LessonPlansResource;
+        readonly placement: import("./resources").PlacementResource;
+        readonly screening: import("./resources").ScreeningResource;
+        readonly syllabus: import("./resources").SyllabusResource;
+        readonly testAssignments: import("./resources").TestAssignmentsResource;
+        getTransport(): import("./types").PowerPathTransportLike;
+        checkAuth(): Promise<import("@timeback/internal-client-infra").AuthCheckResult>;
+    };
+};
+export type { PowerPathClientInstance } from './types';
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;CAA0B,CAAA;AAEtD,YAAY,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA"}

package/dist/constants.d.ts

@@ -0,0 +1,25 @@
+/**
+ * PowerPath Constants
+ *
+ * Configuration constants for the PowerPath client.
+ */
+import type { ClientUrlMaps, Platform } from '@timeback/internal-client-infra';
+/**
+ * Environment variable names for PowerPath configuration fallback.
+ */
+export declare const POWERPATH_ENV_VARS: {
+    readonly baseUrl: "POWERPATH_BASE_URL";
+    readonly clientId: "POWERPATH_CLIENT_ID";
+    readonly clientSecret: "POWERPATH_CLIENT_SECRET";
+    readonly authUrl: "POWERPATH_TOKEN_URL";
+};
+/**
+ * Get URL maps for a specific platform.
+ * Defaults to 'BEYOND_AI' for backwards compatibility.
+ *
+ * Note: PowerPath uses the main API server.
+ * @param platform - Platform name
+ * @returns Client URL maps for the platform
+ */
+export declare function getUrlMapsForPlatform(platform?: Platform): ClientUrlMaps;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAM9E;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;CAKrB,CAAA;AAMV;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,GAAE,QAA2B,GAAG,aAAa,CAM1F"}

package/dist/errors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * PowerPath Error Classes
+ *
+ * Re-exports common errors from `@timeback/internal-client-infra`.
+ * PowerPath uses the same error format as other Timeback clients.
+ */
+import { ApiError, ForbiddenError, InputValidationError, NotFoundError, UnauthorizedError, ValidationError } from '@timeback/internal-client-infra';
+export { ApiError as PowerPathError, ForbiddenError, InputValidationError, NotFoundError, UnauthorizedError, ValidationError, };
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACN,QAAQ,EACR,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,MAAM,iCAAiC,CAAA;AAExC,OAAO,EACN,QAAQ,IAAI,cAAc,EAC1B,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,iBAAiB,EACjB,eAAe,GACf,CAAA"}