@indigoai-us/hq-cloud 6.15.0 → 6.15.2

package/src/schemas/signal-types.test.ts

@@ -1,82 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  SIGNAL_TYPES,
-  isSignalType,
-  assertSignalType,
-  InvalidSignalTypeError,
-} from "./signal-types.js";
-import type { SignalType } from "./signal-types.js";
-
-describe("SIGNAL_TYPES", () => {
-  it("contains the six canonical types", () => {
-    expect([...SIGNAL_TYPES]).toEqual([
-      "action_item",
-      "commitment",
-      "decision",
-      "key_point",
-      "risk",
-      "summary",
-    ]);
-  });
-
-  it("is frozen (readonly at runtime)", () => {
-    expect(Object.isFrozen(SIGNAL_TYPES)).toBe(true);
-  });
-});
-
-describe("isSignalType", () => {
-  it.each(SIGNAL_TYPES)("returns true for '%s'", (type) => {
-    expect(isSignalType(type)).toBe(true);
-  });
-
-  it("returns false for an invalid string", () => {
-    expect(isSignalType("ramble")).toBe(false);
-  });
-
-  it("returns false for non-string values", () => {
-    expect(isSignalType(42)).toBe(false);
-    expect(isSignalType(null)).toBe(false);
-    expect(isSignalType(undefined)).toBe(false);
-  });
-});
-
-describe("assertSignalType", () => {
-  it.each(SIGNAL_TYPES)("does not throw for '%s'", (type) => {
-    expect(() => assertSignalType(type)).not.toThrow();
-  });
-
-  it("throws InvalidSignalTypeError for invalid value", () => {
-    expect(() => assertSignalType("ramble")).toThrow(InvalidSignalTypeError);
-  });
-
-  it("error message contains the offending value", () => {
-    expect(() => assertSignalType("ramble")).toThrow("'ramble'");
-  });
-
-  it("error message lists all valid types", () => {
-    try {
-      assertSignalType("ramble");
-    } catch (err) {
-      const msg = (err as Error).message;
-      for (const type of SIGNAL_TYPES) {
-        expect(msg).toContain(type);
-      }
-    }
-  });
-
-  it("error message matches snapshot", () => {
-    expect(() => assertSignalType("ramble")).toThrowErrorMatchingInlineSnapshot(
-      `[InvalidSignalTypeError: Invalid signal type: 'ramble'. Valid types: action_item, commitment, decision, key_point, risk, summary]`,
-    );
-  });
-});
-
-describe("SignalType type", () => {
-  it("narrows correctly via type guard", () => {
-    const value: unknown = "action_item";
-    if (isSignalType(value)) {
-      const _type: SignalType = value;
-      expect(_type).toBe("action_item");
-    }
-  });
-});

package/src/schemas/signal-types.ts

@@ -1,38 +0,0 @@
-/**
- * Signal type schema — single source of truth.
- *
- * Closed enum: the six canonical signal types.
- * assertSignalType is the agent-mitigation lever — prevents LLMs
- * from fabricating signal types.
- */
-
-export const SIGNAL_TYPES = Object.freeze([
-  "action_item",
-  "commitment",
-  "decision",
-  "key_point",
-  "risk",
-  "summary",
-] as const);
-
-export type SignalType = (typeof SIGNAL_TYPES)[number];
-
-export class InvalidSignalTypeError extends Error {
-  override readonly name = "InvalidSignalTypeError";
-
-  constructor(value: unknown) {
-    super(
-      `Invalid signal type: '${String(value)}'. Valid types: ${SIGNAL_TYPES.join(", ")}`,
-    );
-  }
-}
-
-export function isSignalType(value: unknown): value is SignalType {
-  return typeof value === "string" && (SIGNAL_TYPES as readonly string[]).includes(value);
-}
-
-export function assertSignalType(value: unknown): asserts value is SignalType {
-  if (!isSignalType(value)) {
-    throw new InvalidSignalTypeError(value);
-  }
-}

package/src/schemas/source-channels.test.ts

@@ -1,82 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  SOURCE_CHANNELS,
-  isSourceChannel,
-  assertSourceChannel,
-  InvalidSourceChannelError,
-} from "./source-channels.js";
-import type { SourceChannel } from "./source-channels.js";
-
-describe("SOURCE_CHANNELS", () => {
-  it("contains the five canonical channels", () => {
-    expect([...SOURCE_CHANNELS]).toEqual([
-      "meeting",
-      "email",
-      "slack",
-      "linear",
-      "notion",
-    ]);
-  });
-
-  it("is frozen (readonly at runtime)", () => {
-    expect(Object.isFrozen(SOURCE_CHANNELS)).toBe(true);
-  });
-});
-
-describe("isSourceChannel", () => {
-  it.each(SOURCE_CHANNELS)("returns true for '%s'", (channel) => {
-    expect(isSourceChannel(channel)).toBe(true);
-  });
-
-  it("returns false for an invalid string", () => {
-    expect(isSourceChannel("pigeon")).toBe(false);
-  });
-
-  it("returns false for non-string values", () => {
-    expect(isSourceChannel(42)).toBe(false);
-    expect(isSourceChannel(null)).toBe(false);
-    expect(isSourceChannel(undefined)).toBe(false);
-  });
-});
-
-describe("assertSourceChannel", () => {
-  it.each(SOURCE_CHANNELS)("does not throw for '%s'", (channel) => {
-    expect(() => assertSourceChannel(channel)).not.toThrow();
-  });
-
-  it("throws InvalidSourceChannelError for invalid value", () => {
-    expect(() => assertSourceChannel("pigeon")).toThrow(InvalidSourceChannelError);
-  });
-
-  it("error message contains the offending value", () => {
-    expect(() => assertSourceChannel("pigeon")).toThrow("'pigeon'");
-  });
-
-  it("error message lists all valid channels", () => {
-    try {
-      assertSourceChannel("pigeon");
-    } catch (err) {
-      const msg = (err as Error).message;
-      for (const channel of SOURCE_CHANNELS) {
-        expect(msg).toContain(channel);
-      }
-    }
-  });
-
-  it("error message matches snapshot", () => {
-    expect(() => assertSourceChannel("pigeon")).toThrowErrorMatchingInlineSnapshot(
-      `[InvalidSourceChannelError: Invalid source channel: 'pigeon'. Valid channels: meeting, email, slack, linear, notion]`,
-    );
-  });
-});
-
-describe("SourceChannel type", () => {
-  it("narrows correctly via type guard", () => {
-    const value: unknown = "meeting";
-    if (isSourceChannel(value)) {
-      // TypeScript narrows to SourceChannel — compile-time check
-      const _channel: SourceChannel = value;
-      expect(_channel).toBe("meeting");
-    }
-  });
-});

package/src/schemas/source-channels.ts

@@ -1,53 +0,0 @@
-/**
- * Source channel schema — single source of truth.
- *
- * Closed enum: extension requires a code change (PR).
- * Matches the sources-pipeline SourceChannel type.
- */
-
-export const SOURCE_CHANNELS = Object.freeze([
-  "meeting",
-  "email",
-  "slack",
-  "linear",
-  "notion",
-] as const);
-
-export type SourceChannel = (typeof SOURCE_CHANNELS)[number];
-
-export class InvalidSourceChannelError extends Error {
-  override readonly name = "InvalidSourceChannelError";
-
-  constructor(value: unknown) {
-    super(
-      `Invalid source channel: '${String(value)}'. Valid channels: ${SOURCE_CHANNELS.join(", ")}`,
-    );
-  }
-}
-
-export function isSourceChannel(value: unknown): value is SourceChannel {
-  return typeof value === "string" && (SOURCE_CHANNELS as readonly string[]).includes(value);
-}
-
-export function assertSourceChannel(value: unknown): asserts value is SourceChannel {
-  if (!isSourceChannel(value)) {
-    throw new InvalidSourceChannelError(value);
-  }
-}
-
-/**
- * Map a source channel (singular enum value) to the S3 path segment used by
- * sources-pipeline writers. The sources-pipeline (hq-pro) uses plural for
- * meetings only; the other channels pass through:
- *
- *   meeting → meetings
- *   email   → email
- *   slack   → slack
- *   linear  → linear
- *   notion  → notion
- *
- * Keep in sync with hq-pro/src/sources/s3-paths.ts:sourcePathSegment().
- */
-export function sourcePathSegment(channel: SourceChannel): string {
-  return channel === "meeting" ? "meetings" : channel;
-}