whale-code 6.5.11 → 6.6.0

package/dist/cli/services/format-server-response-realworld.test.js

@@ -1,248 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { formatServerResponse } from "./format-server-response.js";
-function setTerminalWidth(cols) {
-  Object.defineProperty(process.stdout, "columns", {
-    value: cols,
-    writable: true,
-    configurable: true
-  });
-}
-describe("formatServerResponse — advanced types and real-world shapes", () => {
-  let originalColumns;
-  beforeEach(() => {
-    originalColumns = process.stdout.columns;
-    setTerminalWidth(120);
-  });
-  afterEach(() => {
-    if (originalColumns !== undefined) {
-      setTerminalWidth(originalColumns);
-    } else {
-      Object.defineProperty(process.stdout, "columns", {
-        value: originalColumns,
-        writable: true,
-        configurable: true
-      });
-    }
-  });
-  describe("flat vs non-flat object detection", () => {
-    it("treats object with only primitives and arrays as flat", () => {
-      const data = {
-        name: "Test",
-        count: 5,
-        active: true,
-        tags: ["a", "b"]
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("**Name**: Test");
-      expect(result).toContain("**Count**: 5");
-      expect(result).not.toContain("```json");
-    });
-    it("renders objects with nested objects as key-value pairs (scalars only)", () => {
-      const data = {
-        name: "Test",
-        config: {
-          key: "value"
-        }
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("**Name**: Test");
-    });
-    it("treats arrays as not flat objects", () => {
-      const data = [1, 2, 3];
-      const result = formatServerResponse(data);
-      expect(result).toContain("```json");
-    });
-  });
-  describe("objects with all low-priority keys", () => {
-    it("falls back to JSON when all keys are low priority", () => {
-      const data = {
-        id: "abc",
-        store_id: "def",
-        created_at: "2025-01-01",
-        updated_at: "2025-01-02"
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("**ID**: abc");
-    });
-  });
-  describe("large datasets", () => {
-    it("handles many rows without crashing", () => {
-      const data = Array.from({
-        length: 100
-      }, (_, i) => ({
-        name: `Item ${i}`,
-        quantity: i * 10,
-        status: i % 2 === 0 ? "active" : "inactive"
-      }));
-      const result = formatServerResponse(data);
-      expect(result).toContain("(100 results)");
-      expect(result).toContain("Item 0");
-      expect(result).toContain("Item 99");
-    });
-    it("caps individual column width at 30 characters", () => {
-      const longName = "A".repeat(250);
-      const data = [{
-        category: longName,
-        qty: 1
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("...");
-      expect(result).not.toContain("A".repeat(250));
-    });
-  });
-  describe("number formatting", () => {
-    it("formats large numbers with locale separators", () => {
-      const data = [{
-        name: "Big",
-        count: 1000000
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("1,000,000");
-    });
-    it("formats zero correctly", () => {
-      const data = {
-        count: 0
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("0");
-    });
-    it("formats negative numbers", () => {
-      const data = {
-        balance: -500
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("-500");
-    });
-  });
-  describe("real-world response shapes", () => {
-    it("formats an analytics summary response (flat object with array)", () => {
-      const data = {
-        period: "last_30",
-        total_revenue: 45000,
-        total_orders: 320,
-        average_order_value: 140.63,
-        data: [{
-          name: "Flower",
-          revenue: 25000,
-          quantity: 200,
-          count: 180
-        }, {
-          name: "Edibles",
-          revenue: 12000,
-          quantity: 80,
-          count: 90
-        }, {
-          name: "Vapes",
-          revenue: 8000,
-          quantity: 40,
-          count: 50
-        }]
-      };
-      const result = formatServerResponse(data, "analytics");
-      expect(result).toContain("**Period**: last_30");
-      expect(result).toContain("**Total Revenue**: $45,000.00");
-      expect(result).toContain("Flower");
-      expect(result).toContain("Edibles");
-    });
-    it("formats an analytics wrapper response with nested metadata", () => {
-      const data = {
-        period: "last_30",
-        meta: {
-          generated: "2025-01-01"
-        },
-        data: [{
-          name: "Flower",
-          revenue: 25000,
-          quantity: 200,
-          count: 180
-        }, {
-          name: "Edibles",
-          revenue: 12000,
-          quantity: 80,
-          count: 90
-        }]
-      };
-      const result = formatServerResponse(data, "analytics");
-      expect(result).toContain("**Period**: last_30");
-      expect(result).toContain("Flower");
-      expect(result).toContain("Edibles");
-    });
-    it("formats an inventory summary response", () => {
-      const data = [{
-        product_name: "Blue Dream",
-        quantity: 50,
-        location_name: "Main Store",
-        status: "in_stock"
-      }, {
-        product_name: "OG Kush",
-        quantity: 0,
-        location_name: "Main Store",
-        status: "out_of_stock"
-      }];
-      const result = formatServerResponse(data, "inventory");
-      expect(result).toContain("**Inventory**");
-      expect(result).toContain("Blue Dream");
-      expect(result).toContain("OG Kush");
-    });
-    it("formats a customer find response", () => {
-      const data = [{
-        first_name: "Alice",
-        last_name: "Smith",
-        email: "alice@example.com",
-        phone: "555-0001",
-        status: "active",
-        loyalty_tier: "Gold",
-        id: "550e8400-e29b-41d4-a716-446655440000",
-        store_id: "660e8400-e29b-41d4-a716-446655440000",
-        created_at: "2025-01-15T08:30:00Z"
-      }];
-      const result = formatServerResponse(data, "customers");
-      expect(result).toContain("**Customers**");
-      expect(result).toContain("Alice");
-      expect(result).toContain("Smith");
-      expect(result).toContain("alice@example.com");
-      expect(result).toContain("Gold");
-      expect(result).toContain("IDs: Alice=");
-    });
-    it("formats an order detail response", () => {
-      const data = {
-        order_number: "ORD-2025-001",
-        status: "completed",
-        total: 250.00,
-        subtotal: 230.00,
-        tax: 20.00,
-        customer_name: "Bob Jones"
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("**Order Number**: ORD-2025-001");
-      expect(result).toContain("**Status**: completed");
-      expect(result).toContain("250");
-      expect(result).toContain("$230.00");
-      expect(result).toContain("$20.00");
-    });
-  });
-  describe("array edge cases", () => {
-    it("falls back to JSON for array starting with null", () => {
-      const data = [null, {
-        name: "test"
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("```json");
-    });
-    it("falls back to JSON for array of strings", () => {
-      const data = ["apple", "banana", "cherry"];
-      const result = formatServerResponse(data);
-      expect(result).toContain("```json");
-    });
-    it("falls back to JSON for array of numbers", () => {
-      const data = [1, 2, 3];
-      const result = formatServerResponse(data);
-      expect(result).toContain("```json");
-    });
-    it("falls back to JSON for array of booleans", () => {
-      const data = [true, false, true];
-      const result = formatServerResponse(data);
-      expect(result).toContain("```json");
-    });
-  });
-});

package/dist/cli/services/format-server-response-values.test.js

@@ -1,247 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { formatServerResponse } from "./format-server-response.js";
-function setTerminalWidth(cols) {
-  Object.defineProperty(process.stdout, "columns", {
-    value: cols,
-    writable: true,
-    configurable: true
-  });
-}
-describe("formatServerResponse — value formatting", () => {
-  let originalColumns;
-  beforeEach(() => {
-    originalColumns = process.stdout.columns;
-    setTerminalWidth(120);
-  });
-  afterEach(() => {
-    if (originalColumns !== undefined) {
-      setTerminalWidth(originalColumns);
-    } else {
-      Object.defineProperty(process.stdout, "columns", {
-        value: originalColumns,
-        writable: true,
-        configurable: true
-      });
-    }
-  });
-  describe("JSON fallback", () => {
-    it("falls back to JSON fence for deeply nested objects", () => {
-      const data = {
-        level1: {
-          level2: {
-            level3: "deep"
-          }
-        }
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("```json");
-      expect(result).toContain("```");
-      expect(result).toContain('"level3": "deep"');
-    });
-    it("falls back to JSON for arrays of primitives", () => {
-      const data = [1, 2, 3, 4, 5];
-      const result = formatServerResponse(data);
-      expect(result).toContain("```json");
-    });
-    it("falls back to JSON for boolean primitives", () => {
-      const result = formatServerResponse(true);
-      expect(result).toContain("```json");
-      expect(result).toContain("true");
-    });
-    it("falls back to JSON for number primitives", () => {
-      const result = formatServerResponse(42);
-      expect(result).toContain("```json");
-      expect(result).toContain("42");
-    });
-    it("falls back to JSON for object with > 20 flat entries", () => {
-      const data = {};
-      for (let i = 0; i < 25; i++) {
-        data[`field_${i}`] = `value_${i}`;
-      }
-      const result = formatServerResponse(data);
-      expect(result).toContain("```json");
-    });
-  });
-  describe("value formatting in tables", () => {
-    it("formats null/undefined as em dash", () => {
-      const data = [{
-        name: "Test",
-        optional: null
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("\u2014");
-    });
-    it("formats booleans as check/cross marks", () => {
-      const data = [{
-        name: "Feature",
-        enabled: true,
-        deprecated: false
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("\u2713");
-      expect(result).toContain("\u2715");
-    });
-    it("truncates UUIDs to 8 characters", () => {
-      const uuid = "550e8400-e29b-41d4-a716-446655440000";
-      const data = [{
-        name: "Item",
-        ref: uuid
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("550e8400");
-      expect(result).not.toContain("446655440000");
-    });
-    it("formats ISO dates to YYYY-MM-DD", () => {
-      const data = [{
-        name: "Event",
-        date: "2025-06-15T14:30:00Z"
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("2025-06-15");
-      expect(result).not.toContain("T14:30:00Z");
-    });
-    it("formats money-like strings with dollar sign", () => {
-      const data = {
-        revenue: "1234.56"
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("$");
-    });
-    it("excludes array columns from table", () => {
-      const data = [{
-        name: "Group",
-        members: ["a", "b", "c"]
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("Group");
-      expect(result).not.toContain("Members");
-    });
-    it("extracts name from nested objects instead of {...}", () => {
-      const data = {
-        name: "Test",
-        config: {
-          nested: true
-        }
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("**Name**: Test");
-    });
-    it("truncates strings longer than 200 characters", () => {
-      const longStr = "A".repeat(250);
-      const data = [{
-        name: longStr
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("...");
-      expect(result).not.toContain("A".repeat(250));
-    });
-  });
-  describe("money key detection and formatting", () => {
-    it("detects price as money key", () => {
-      const data = [{
-        name: "Widget",
-        price: 19.99
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("$19.99");
-    });
-    it("detects revenue as money key", () => {
-      const data = [{
-        name: "Q1",
-        revenue: 50000
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("$50,000.00");
-    });
-    it("does not treat bare 'total' as money key", () => {
-      const data = [{
-        name: "Order",
-        total: 125
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("125");
-      expect(result).not.toContain("$125");
-    });
-    it("detects total_amount as money key", () => {
-      const data = [{
-        name: "Order",
-        total_amount: 125.5
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("$125.50");
-    });
-    it("detects cost as money key", () => {
-      const data = {
-        cost_price: 8.5
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("$8.50");
-    });
-    it("detects subtotal as money key", () => {
-      const data = {
-        subtotal: 99.99
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("$99.99");
-    });
-    it("does not add dollar sign to non-money number keys", () => {
-      const data = {
-        name: "Test",
-        quantity: 42
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("42");
-      const quantityLine = result.split("\n").find(l => l.includes("Quantity"));
-      expect(quantityLine).toBeDefined();
-      expect(quantityLine).not.toContain("$");
-    });
-  });
-  describe("percentage key detection and formatting", () => {
-    it("formats percentage keys with % suffix", () => {
-      const data = [{
-        name: "Blue Dream",
-        thca_percentage: 26.5
-      }];
-      const result = formatServerResponse(data);
-      expect(result).toContain("26.5%");
-    });
-    it("formats _pct keys with % suffix", () => {
-      const data = {
-        success_pct: 98.2
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("98.2%");
-    });
-    it("does not add % to non-percentage number keys", () => {
-      const data = {
-        name: "Test",
-        quantity: 42
-      };
-      const result = formatServerResponse(data);
-      expect(result).not.toContain("42%");
-    });
-  });
-  describe("key prettification", () => {
-    it("converts snake_case to Title Case", () => {
-      const data = {
-        first_name: "John"
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("**First Name**: John");
-    });
-    it("capitalizes 'id' to 'ID'", () => {
-      const data = {
-        customer_id_ref: "abc123"
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("Customer ID Ref");
-    });
-    it("handles single word keys", () => {
-      const data = {
-        name: "Solo"
-      };
-      const result = formatServerResponse(data);
-      expect(result).toContain("**Name**: Solo");
-    });
-  });
-});

package/dist/cli/services/hooks-runners.test.js

@@ -1,184 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { runBeforeToolHook, runAfterToolHook, runSessionHook } from "./hooks.js";
-
-// ============================================================================
-// runBeforeToolHook
-// ============================================================================
-
-describe("runBeforeToolHook", () => {
-  it("returns allow: true when no hooks match", async () => {
-    const result = await runBeforeToolHook([], "bash", {
-      command: "ls"
-    });
-    expect(result.allow).toBe(true);
-  });
-  it("returns allow: true when hooks have non-matching patterns", async () => {
-    const hooks = [{
-      event: "BeforeTool",
-      command: "echo hi",
-      pattern: "read_*"
-    }];
-    const result = await runBeforeToolHook(hooks, "bash", {
-      command: "ls"
-    });
-    expect(result.allow).toBe(true);
-  });
-  it("blocks when hook outputs allow: false", async () => {
-    const hooks = [{
-      event: "BeforeTool",
-      command: 'echo \'{"allow": false, "message": "no bash allowed"}\''
-    }];
-    const result = await runBeforeToolHook(hooks, "bash", {
-      command: "ls"
-    });
-    expect(result.allow).toBe(false);
-    expect(result.message).toBe("no bash allowed");
-  });
-  it("allows when hook exits non-zero (warning only)", async () => {
-    const hooks = [{
-      event: "BeforeTool",
-      command: "exit 1"
-    }];
-    const result = await runBeforeToolHook(hooks, "bash", {
-      command: "ls"
-    });
-    expect(result.allow).toBe(true);
-  });
-  it("returns modified input when allowModify is true", async () => {
-    const hooks = [{
-      event: "BeforeTool",
-      command: 'echo \'{"modified_input": {"command": "ls -la"}}\'',
-      allowModify: true
-    }];
-    const result = await runBeforeToolHook(hooks, "bash", {
-      command: "ls"
-    });
-    expect(result.allow).toBe(true);
-    expect(result.modifiedInput).toEqual({
-      command: "ls -la"
-    });
-  });
-  it("ignores modified_input when allowModify is false", async () => {
-    const hooks = [{
-      event: "BeforeTool",
-      command: 'echo \'{"modified_input": {"command": "rm -rf /"}}\'',
-      allowModify: false
-    }];
-    const result = await runBeforeToolHook(hooks, "bash", {
-      command: "ls"
-    });
-    expect(result.allow).toBe(true);
-    expect(result.modifiedInput).toBeUndefined();
-  });
-  it("pattern-matches tool names with globs", async () => {
-    const hooks = [{
-      event: "BeforeTool",
-      command: 'echo \'{"allow": false, "message": "blocked"}\'',
-      pattern: "write_*"
-    }];
-
-    // Should not match
-    const r1 = await runBeforeToolHook(hooks, "read_file", {});
-    expect(r1.allow).toBe(true);
-
-    // Should match
-    const r2 = await runBeforeToolHook(hooks, "write_file", {});
-    expect(r2.allow).toBe(false);
-  });
-  it("skips AfterTool hooks", async () => {
-    const hooks = [{
-      event: "AfterTool",
-      command: 'echo \'{"allow": false}\''
-    }];
-    const result = await runBeforeToolHook(hooks, "bash", {
-      command: "ls"
-    });
-    expect(result.allow).toBe(true);
-  });
-});
-
-// ============================================================================
-// runAfterToolHook
-// ============================================================================
-
-describe("runAfterToolHook", () => {
-  it("returns empty when no hooks match", async () => {
-    const result = await runAfterToolHook([], "bash", "output", true);
-    expect(result).toEqual({});
-  });
-  it("returns modified output when allowModify is true", async () => {
-    const hooks = [{
-      event: "AfterTool",
-      command: 'echo \'{"modified_output": "cleaned output"}\'',
-      allowModify: true
-    }];
-    const result = await runAfterToolHook(hooks, "bash", "raw output", true);
-    expect(result.modifiedOutput).toBe("cleaned output");
-  });
-  it("ignores modified_output when allowModify is false", async () => {
-    const hooks = [{
-      event: "AfterTool",
-      command: 'echo \'{"modified_output": "hacked output"}\'',
-      allowModify: false
-    }];
-    const result = await runAfterToolHook(hooks, "bash", "real output", true);
-    expect(result.modifiedOutput).toBeUndefined();
-  });
-  it("skips BeforeTool hooks", async () => {
-    const hooks = [{
-      event: "BeforeTool",
-      command: 'echo \'{"modified_output": "should not appear"}\'',
-      allowModify: true
-    }];
-    const result = await runAfterToolHook(hooks, "bash", "output", true);
-    expect(result).toEqual({});
-  });
-});
-
-// ============================================================================
-// runSessionHook
-// ============================================================================
-
-describe("runSessionHook", () => {
-  it("completes without error when no hooks match", async () => {
-    await expect(runSessionHook([], "SessionStart", {})).resolves.not.toThrow();
-  });
-  it("runs matching session hooks", async () => {
-    const hooks = [{
-      event: "SessionStart",
-      command: "true"
-    }, {
-      event: "SessionEnd",
-      command: "true"
-    }];
-
-    // Should not throw
-    await runSessionHook(hooks, "SessionStart");
-    await runSessionHook(hooks, "SessionEnd");
-  });
-  it("does not throw when hook fails", async () => {
-    const hooks = [{
-      event: "SessionStart",
-      command: "exit 1"
-    }];
-    await expect(runSessionHook(hooks, "SessionStart")).resolves.not.toThrow();
-  });
-  it("runs multiple session hooks concurrently", async () => {
-    const hooks = [{
-      event: "SessionStart",
-      command: "true"
-    }, {
-      event: "SessionStart",
-      command: "true"
-    }, {
-      event: "SessionStart",
-      command: "true"
-    }];
-    const start = Date.now();
-    await runSessionHook(hooks, "SessionStart");
-    const elapsed = Date.now() - start;
-
-    // All should run in parallel, so should be fast
-    expect(elapsed).toBeLessThan(3000);
-  });
-});