mindsim 0.1.1 → 0.1.3

package/src/resources/snapshots.ts

@@ -5,8 +5,10 @@ import type {
   CreateSnapshotFromFileParams,
   CreateSnapshotParams,
   CreateSnapshotResponse,
+  DigitalTwinMindAssessment,
   GetSignedUrlResponse,
   ListSnapshotsResponse,
+  SnapshotDetailResponse,
   SnapshotStatus,
 } from "../types";
 
@@ -41,6 +43,36 @@ export class SnapshotsResource {
     return response.data;
   }
 
+  /**
+   * Get details of a specific snapshot, optionally including transcripts and psychometrics
+   */
+  async getDetail(
+    mindId: string,
+    snapshotId: string,
+    options?: { includeTranscript?: boolean; includePsychometrics?: boolean },
+  ): Promise<SnapshotDetailResponse> {
+    const response = await this.client.get<SnapshotDetailResponse>(
+      `/minds/${mindId}/snapshots/${snapshotId}`,
+      {
+        params: options,
+      },
+    );
+    return response.data;
+  }
+
+  /**
+   * Delete a snapshot
+   */
+  async delete(
+    mindId: string,
+    snapshotId: string,
+  ): Promise<{ message: string; snapshotId: string }> {
+    const response = await this.client.delete<{ message: string; snapshotId: string }>(
+      `/minds/${mindId}/snapshots/${snapshotId}`,
+    );
+    return response.data;
+  }
+
   /**
    * Create a snapshot via a signed url. Recommended for large files.
    */
@@ -123,4 +155,32 @@ export class SnapshotsResource {
     );
     return response.data;
   }
+
+  /**
+   * Link a snapshot to the Digital Twin
+   */
+  async link(
+    mindId: string,
+    snapshotId: string,
+  ): Promise<{ message: string; snapshot: DigitalTwinMindAssessment }> {
+    const response = await this.client.post<{
+      message: string;
+      snapshot: DigitalTwinMindAssessment;
+    }>(`/minds/${mindId}/snapshots/${snapshotId}/link`);
+    return response.data;
+  }
+
+  /**
+   * Unlink a snapshot from the Digital Twin
+   */
+  async unlink(
+    mindId: string,
+    snapshotId: string,
+  ): Promise<{ message: string; snapshot: DigitalTwinMindAssessment[] }> {
+    const response = await this.client.post<{
+      message: string;
+      snapshot: DigitalTwinMindAssessment[];
+    }>(`/minds/${mindId}/snapshots/${snapshotId}/unlink`);
+    return response.data;
+  }
 }

package/src/resources/users.ts

@@ -0,0 +1,16 @@
+import type { AxiosInstance } from "axios";
+import type { ListUsersResponse } from "../types";
+
+export class UsersResource {
+  constructor(private client: AxiosInstance) {}
+
+  /**
+   * List users in the organization
+   */
+  async list(params?: { limit?: number; offset?: number }): Promise<ListUsersResponse> {
+    const response = await this.client.get<ListUsersResponse>("/organizations/users", {
+      params,
+    });
+    return response.data;
+  }
+}

package/src/types.ts

@@ -1,13 +1,56 @@
-export interface AuthConfig {
-  authServerUrl: string;
-  authServerLandingPath: string;
-  authRedirectPath: string;
-  listenPort: string;
+export interface DeviceAuthConfig {
+  deviceAuthUrl: string;
+  tokenUrl: string;
+  clientId: string;
+  sdkKeysApiUrl: string;
 }
 
-export interface AuthResponse {
-  apiKey?: {
+export interface DeviceAuthResponse {
+  device_code: string;
+  user_code: string;
+  verification_uri: string;
+  verification_uri_complete: string;
+  expires_in: number;
+  interval: number;
+}
+
+export interface TokenResponse {
+  access_token: string;
+  refresh_token?: string;
+  user?: Record<string, unknown>;
+}
+
+export interface SdkKeysResponse {
+  success: boolean;
+  user: {
     id: string;
+    workosUserId: string;
+    email: string;
+    firstName: string | null;
+    lastName: string | null;
+  };
+  keys: SdkKeyInfo[];
+}
+
+export interface SdkKeyInfo {
+  id: string;
+  name: string;
+  description: string | null;
+  tier: "development" | "production";
+  lastUsedAt: string | null;
+  createdAt: string;
+  app: {
+    id: string;
+    name: string;
+    description: string | null;
+    mindsimOrgId: string;
+    mindsimOrgName: string | null;
+  } | null;
+}
+
+export interface SdkKeyDetailResponse {
+  success: boolean;
+  key: SdkKeyInfo & {
     key: string;
   };
 }
@@ -34,6 +77,7 @@ export interface Mind {
   createdAt?: string;
   updatedAt?: string;
   tags: Tag[];
+  snapshotCount?: number;
 }
 
 export interface CreateMindRequest {
@@ -66,6 +110,8 @@ export interface SimulationScenario {
 export interface RunSimulationRequest {
   mindId: string;
   scenario: SimulationScenario;
+  conversationId?: string;
+  stream?: boolean;
   runInBackground?: boolean;
 }
 
@@ -160,11 +206,24 @@ export interface MindAssessment {
   findingCount?: number | null;
 }
 
+export interface SnapshotDetailResponse extends MindAssessment {
+  transcripts?: any[];
+  psychometrics?: any;
+}
+
 export interface ListSnapshotsResponse {
   snapshots: MindAssessment[];
   count: number;
 }
 
+export interface DigitalTwinMindAssessment {
+  id: string;
+  digitalTwinId: string;
+  mindAssessmentId: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
 // -- Psychometrics --
 
 export interface PersonDetails {
@@ -183,3 +242,25 @@ export interface GetPsychometricsResponse {
   topicsSentimentSummary?: Record<string, any> | null;
   mindReasonerStopError?: any | null;
 }
+
+export interface GetMindTopicsResponse {
+  personDetails: PersonDetails;
+  topicsSentimentSummary?: Record<string, any> | null;
+  mindReasonerStopError?: any | null;
+}
+
+// -- Users --
+
+export interface User {
+  id: string;
+  name: string;
+  email: string;
+  imageUrl?: string | null;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface ListUsersResponse {
+  users: User[];
+  count: number;
+}

package/tests/config.test.ts

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, beforeEach, describe, expect, it, type Mocked, vi } from "vitest";
-import { getApiBaseUrl, getAuthConfig, loadApiKey, saveApiKey } from "../src/config";
+import { getApiBaseUrl, getDeviceAuthConfig, loadApiKey, saveApiKey } from "../src/config";
 
 // Mock Node built-ins
 vi.mock("node:fs");
@@ -96,29 +96,34 @@ describe("Config Module", () => {
     });
   });
 
-  describe("getAuthConfig", () => {
+  describe("getDeviceAuthConfig", () => {
     it("should return default values when env vars are not set", () => {
-      const config = getAuthConfig();
-      expect(config.authServerUrl).toBe("https://app.mindsim.com/sdk/authorize");
-      expect(config.authRedirectPath).toBe("http://localhost:4242/callback");
-      expect(config.listenPort).toBe("4242");
+      const config = getDeviceAuthConfig();
+      expect(config.deviceAuthUrl).toBe(
+        "https://auth.reasoner.com/user_management/authorize/device",
+      );
+      expect(config.tokenUrl).toBe("https://auth.reasoner.com/user_management/authenticate");
+      expect(config.clientId).toBe("client_01GPECHM1J9DMY7WQNKTJ195P6");
+      expect(config.sdkKeysApiUrl).toBe("https://api.reasoner.com/api/sdk/keys");
     });
 
     it("should return env overrides when set", () => {
-      vi.stubEnv("MINDSIM_AUTH_SERVER_URL", "https://dev.mindsim.com/auth");
-      vi.stubEnv("MINDSIM_AUTH_REDIRECT_URI", "http://custom-callback");
-      vi.stubEnv("MINDSIM_AUTH_PORT", "8080");
-
-      const config = getAuthConfig();
-      expect(config.authServerUrl).toBe("https://dev.mindsim.com/auth");
-      expect(config.authRedirectPath).toBe("http://custom-callback");
-      expect(config.listenPort).toBe("8080");
+      vi.stubEnv("MINDSIM_WORKOS_DEVICE_AUTH_URL", "https://custom-auth.example.com/device");
+      vi.stubEnv("MINDSIM_WORKOS_TOKEN_URL", "https://custom-auth.example.com/token");
+      vi.stubEnv("MINDSIM_WORKOS_CLIENT_ID", "custom_client_id");
+      vi.stubEnv("MINDSIM_SDK_KEYS_API_URL", "https://custom-api.example.com/keys");
+
+      const config = getDeviceAuthConfig();
+      expect(config.deviceAuthUrl).toBe("https://custom-auth.example.com/device");
+      expect(config.tokenUrl).toBe("https://custom-auth.example.com/token");
+      expect(config.clientId).toBe("custom_client_id");
+      expect(config.sdkKeysApiUrl).toBe("https://custom-api.example.com/keys");
     });
   });
 
   describe("getApiBaseUrl", () => {
     it("should return default URL", () => {
-      expect(getApiBaseUrl()).toBe("https://app.mindsim.com/api/public/v1");
+      expect(getApiBaseUrl()).toBe("https://api.reasoner.com/api/mindsim");
     });
 
     it("should return override from environment", () => {

package/tests/resources/mind-topics.test.ts

@@ -0,0 +1,69 @@
+import axios from "axios";
+import { beforeEach, describe, expect, it, type Mocked, vi } from "vitest";
+import { MindSim } from "../../src/index";
+import type { GetMindTopicsResponse } from "../../src/types";
+
+vi.mock("axios");
+const mockedAxios = axios as Mocked<typeof axios>;
+
+describe("MindSim Mind Topics Resource", () => {
+  let mindsim: MindSim;
+  const SNAPSHOT_ID = "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11";
+
+  const mockClient = {
+    get: vi.fn(),
+    defaults: { headers: { common: {} } },
+    interceptors: { request: { use: vi.fn() }, response: { use: vi.fn() } },
+  };
+
+  beforeEach(() => {
+    mockedAxios.create.mockReturnValue(mockClient as any);
+    mindsim = new MindSim("test-api-key");
+  });
+
+  it("get() should retrieve topic analysis for a snapshot", async () => {
+    const mockResponse: GetMindTopicsResponse = {
+      personDetails: {
+        id: "p1",
+        name: "Test Subject",
+        mindDate: "2023-01-01",
+        mindAssesssmentId: SNAPSHOT_ID,
+      },
+      topicsSentimentSummary: {
+        topics: [
+          { name: "Coding", sentiment: "Positive" },
+          { name: "Meetings", sentiment: "Negative" },
+        ],
+      },
+      mindReasonerStopError: null,
+    };
+
+    mockClient.get.mockResolvedValue({ data: mockResponse });
+
+    const result = await mindsim.mindTopics.get(SNAPSHOT_ID);
+
+    expect(mockClient.get).toHaveBeenCalledWith(`/snapshots/${SNAPSHOT_ID}/mind-topics`);
+    expect(result.personDetails.name).toBe("Test Subject");
+    expect(result.topicsSentimentSummary?.topics).toHaveLength(2);
+  });
+
+  it("get() should handle missing optional fields gracefully", async () => {
+    // API might return minimal data if processing isn't fully complete or data is sparse
+    const mockResponse: GetMindTopicsResponse = {
+      personDetails: {
+        id: "p1",
+        name: "Test Subject",
+        mindDate: "2023-01-01",
+        mindAssesssmentId: SNAPSHOT_ID,
+      },
+      topicsSentimentSummary: null,
+      mindReasonerStopError: null,
+    };
+
+    mockClient.get.mockResolvedValue({ data: mockResponse });
+
+    const result = await mindsim.mindTopics.get(SNAPSHOT_ID);
+
+    expect(result.topicsSentimentSummary).toBeNull();
+  });
+});

package/tests/resources/snapshots.test.ts

@@ -17,6 +17,7 @@ describe("MindSim Snapshots Resource", () => {
     get: vi.fn(),
     post: vi.fn(),
     put: vi.fn(),
+    delete: vi.fn(), // Added delete mock
     defaults: { headers: { common: {} } },
     interceptors: { request: { use: vi.fn() }, response: { use: vi.fn() } },
   };
@@ -26,6 +27,7 @@ describe("MindSim Snapshots Resource", () => {
     mindsim = new MindSim("fake-key");
   });
 
+  // ... (Existing list, create, createFromFile, getStatus tests remain unchanged) ...
   it("list() should retrieve snapshots for a mind", async () => {
     const mockList = {
       snapshots: [{ id: ASSESSMENT_ID, status: "completed" }],
@@ -132,4 +134,48 @@ describe("MindSim Snapshots Resource", () => {
       `/minds/${MIND_ID}/snapshots/${ASSESSMENT_ID}/status`,
     );
   });
+
+  // NEW TESTS
+
+  it("getDetail() should retrieve details with query params", async () => {
+    mockApiClient.get.mockResolvedValue({
+      data: { id: ASSESSMENT_ID, status: "completed", transcripts: ["foo"] },
+    });
+
+    const result = await mindsim.snapshots.getDetail(MIND_ID, ASSESSMENT_ID, {
+      includeTranscript: true,
+    });
+
+    expect(mockApiClient.get).toHaveBeenCalledWith(`/minds/${MIND_ID}/snapshots/${ASSESSMENT_ID}`, {
+      params: { includeTranscript: true },
+    });
+    expect(result.transcripts).toHaveLength(1);
+  });
+
+  it("delete() should remove snapshot", async () => {
+    mockApiClient.delete.mockResolvedValue({
+      data: { message: "deleted", snapshotId: ASSESSMENT_ID },
+    });
+
+    await mindsim.snapshots.delete(MIND_ID, ASSESSMENT_ID);
+    expect(mockApiClient.delete).toHaveBeenCalledWith(
+      `/minds/${MIND_ID}/snapshots/${ASSESSMENT_ID}`,
+    );
+  });
+
+  it("link() should post to link endpoint", async () => {
+    mockApiClient.post.mockResolvedValue({ data: { message: "linked" } });
+    await mindsim.snapshots.link(MIND_ID, ASSESSMENT_ID);
+    expect(mockApiClient.post).toHaveBeenCalledWith(
+      `/minds/${MIND_ID}/snapshots/${ASSESSMENT_ID}/link`,
+    );
+  });
+
+  it("unlink() should post to unlink endpoint", async () => {
+    mockApiClient.post.mockResolvedValue({ data: { message: "unlinked" } });
+    await mindsim.snapshots.unlink(MIND_ID, ASSESSMENT_ID);
+    expect(mockApiClient.post).toHaveBeenCalledWith(
+      `/minds/${MIND_ID}/snapshots/${ASSESSMENT_ID}/unlink`,
+    );
+  });
 });

package/tests/resources/users.test.ts

@@ -0,0 +1,54 @@
+import axios from "axios";
+import { beforeEach, describe, expect, it, type Mocked, vi } from "vitest";
+import { MindSim } from "../../src/index";
+import type { ListUsersResponse } from "../../src/types";
+
+vi.mock("axios");
+const mockedAxios = axios as Mocked<typeof axios>;
+
+describe("MindSim Users Resource", () => {
+  let mindsim: MindSim;
+
+  const mockClient = {
+    get: vi.fn(),
+    defaults: { headers: { common: {} } },
+    interceptors: { request: { use: vi.fn() }, response: { use: vi.fn() } },
+  };
+
+  beforeEach(() => {
+    mockedAxios.create.mockReturnValue(mockClient as any);
+    mindsim = new MindSim("test-api-key");
+  });
+
+  it("list() should call /organizations/users endpoint", async () => {
+    const mockResponse: ListUsersResponse = {
+      users: [
+        { id: "u1", name: "Alice", email: "alice@test.com" },
+        { id: "u2", name: "Bob", email: "bob@test.com" },
+      ],
+      count: 2,
+    };
+
+    mockClient.get.mockResolvedValue({ data: mockResponse });
+
+    const result = await mindsim.users.list();
+
+    expect(mockClient.get).toHaveBeenCalledWith("/organizations/users", {
+      params: undefined,
+    });
+    expect(result.count).toBe(2);
+    expect(result.users[0].name).toBe("Alice");
+  });
+
+  it("list() should pass pagination parameters", async () => {
+    const mockResponse: ListUsersResponse = { users: [], count: 0 };
+    mockClient.get.mockResolvedValue({ data: mockResponse });
+
+    const params = { limit: 10, offset: 5 };
+    await mindsim.users.list(params);
+
+    expect(mockClient.get).toHaveBeenCalledWith("/organizations/users", {
+      params: params,
+    });
+  });
+});

package/tests/version.test.ts

@@ -91,7 +91,7 @@ describe("Version Module", () => {
       mockedFs.existsSync.mockReturnValue(true);
       mockedFs.readFileSync.mockReturnValue("INVALID_JSON");
 
-      const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      vi.spyOn(console, "warn").mockImplementation(() => {});
 
       const version = getPackageVersion();
       expect(version).toBe("0.0.0");