mindsim 0.1.0 → 0.1.2

package/src/types.ts

@@ -34,6 +34,7 @@ export interface Mind {
   createdAt?: string;
   updatedAt?: string;
   tags: Tag[];
+  snapshotCount?: number;
 }
 
 export interface CreateMindRequest {
@@ -66,6 +67,8 @@ export interface SimulationScenario {
 export interface RunSimulationRequest {
   mindId: string;
   scenario: SimulationScenario;
+  conversationId?: string;
+  stream?: boolean;
   runInBackground?: boolean;
 }
 
@@ -160,11 +163,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 +199,48 @@ 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;
+}
+
+// -- Usage --
+
+export interface ApiKeyUsage {
+  successCount: number;
+  errorCount: number;
+  totalCount: number;
+  averageLatency: number;
+  maxLatency: number;
+  minLatency: number;
+  medianLatency: number;
+  p90Latency: number;
+  p95Latency: number;
+  p99Latency: number;
+  p999Latency: number;
+  numberOfSimulations: number;
+  numberOfSimulatedTwins: number;
+  numberOfSnapshotsCreated: number;
+  numberOfSnapshotsTotal: number;
+  numberOfCoresReprocessed: number;
+  numberOfPsychometricsRequests: number;
+  numberOfMindTopicsRequests: number;
+}

package/src/version.ts

@@ -7,7 +7,7 @@ import semver from "semver";
 
 const execAsync = promisify(exec);
 
-const PACKAGE_NAME = "@mindsim/mindsim-sdk-typescript";
+const PACKAGE_NAME = "mindsim";
 const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}`;
 
 /**
@@ -54,7 +54,7 @@ export const checkForUpdates = async (verbose = false): Promise<void> => {
       const changelogUrl = `https://www.npmjs.com/package/${PACKAGE_NAME}/v/${latestVersion}`;
 
       console.warn("\n" + "=".repeat(60));
-      console.warn(`⚠️  UPDATE AVAILABLE: @mindsim/mindsim-sdk-typescript`);
+      console.warn(`⚠️  UPDATE AVAILABLE: mindsim`);
       console.warn("=".repeat(60));
       console.warn(`   Current Version: ${currentVersion}`);
       console.warn(`   Latest Version:  ${latestVersion}`);
@@ -104,8 +104,6 @@ export const updateSdk = async (): Promise<void> => {
     if (error instanceof Error) {
       console.error(error.message);
     }
-    console.error(
-      "Please try running manually: npm install @mindsim/mindsim-sdk-typescript@latest",
-    );
+    console.error("Please try running manually: npm install mindsim@latest");
   }
 };

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/usage.test.ts

@@ -0,0 +1,34 @@
+import axios from "axios";
+import { beforeEach, describe, expect, it, type Mocked, vi } from "vitest";
+import { MindSim } from "../../src/index";
+
+vi.mock("axios");
+const mockedAxios = axios as Mocked<typeof axios>;
+
+describe("MindSim Usage 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-key");
+  });
+
+  it("get() should call /usage with date params", async () => {
+    mockClient.get.mockResolvedValue({
+      data: { totalCount: 100, successCount: 99 },
+    });
+
+    const result = await mindsim.usage.get({ from: "2023-01-01", to: "2023-01-31" });
+
+    expect(mockClient.get).toHaveBeenCalledWith("/usage", {
+      params: { from: "2023-01-01", to: "2023-01-31" },
+    });
+    expect(result.totalCount).toBe(100);
+  });
+});

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

@@ -182,9 +182,7 @@ describe("Version Module", () => {
 
       await updateSdk();
 
-      expect(mockExecAsync).toHaveBeenCalledWith(
-        "npm install @mindsim/mindsim-sdk-typescript@latest --save",
-      );
+      expect(mockExecAsync).toHaveBeenCalledWith("npm install mindsim@latest --save");
       expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining("Update complete"));
     });