@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0-rc.2

package/dist/chunk-BCOQMFKT.js

@@ -0,0 +1,265 @@
+// ../../lib/terminals-tech/core/primitives/interaction.ts
+function createInteractionId() {
+  return `int_${crypto.randomUUID()}`;
+}
+var InteractionBuilder = class {
+  interaction;
+  /**
+   * Create a new InteractionBuilder.
+   *
+   * @param type - The interaction classification
+   */
+  constructor(type) {
+    this.interaction = {
+      id: createInteractionId(),
+      type,
+      status: "initiated",
+      participants: [],
+      childIds: [],
+      createdAt: Date.now(),
+      labels: [],
+      exitCriteria: []
+    };
+  }
+  /**
+   * Set the domain-specific context.
+   */
+  withContext(context) {
+    this.interaction.context = context;
+    return this;
+  }
+  /**
+   * Add a participant to the interaction.
+   *
+   * @param address - Universal address of the participant
+   * @param role - Role within the interaction
+   * @param metadata - Optional participant metadata
+   */
+  addParticipant(address, role, metadata) {
+    const participant = {
+      address,
+      role,
+      joinedAt: Date.now(),
+      metadata
+    };
+    this.interaction.participants.push(participant);
+    return this;
+  }
+  /**
+   * Set the parent interaction for nesting.
+   */
+  withParent(parentId) {
+    this.interaction.parentId = parentId;
+    return this;
+  }
+  /**
+   * Add categorical labels for filtering.
+   */
+  addLabel(...labels) {
+    this.interaction.labels.push(...labels);
+    return this;
+  }
+  /**
+   * Add an exit criterion for workflow completion.
+   *
+   * @param description - Human-readable description
+   * @param condition - Expression or description of the condition
+   */
+  addExitCriterion(description, condition) {
+    this.interaction.exitCriteria.push({
+      id: crypto.randomUUID(),
+      description,
+      condition,
+      met: false
+    });
+    return this;
+  }
+  /**
+   * Set semantic embedding for search.
+   */
+  withEmbedding(embedding) {
+    this.interaction.embedding = embedding;
+    return this;
+  }
+  /**
+   * Set the monotonic ordinal for strict action sequencing.
+   */
+  withOrdinal(ordinal) {
+    this.interaction.ordinal = ordinal;
+    return this;
+  }
+  /**
+   * Track cognitive entropy (uncertainty/complexity) for UI resonance.
+   */
+  withEntropy(entropy) {
+    this.interaction.entropy = entropy;
+    return this;
+  }
+  /**
+   * Track token momentum (generation speed/derivative of attention).
+   */
+  withMomentum(momentum) {
+    this.interaction.momentum = momentum;
+    return this;
+  }
+  /**
+   * Set custom metadata.
+   */
+  withMetadata(metadata) {
+    this.interaction.metadata = metadata;
+    return this;
+  }
+  /**
+   * Override the generated ID (use sparingly).
+   */
+  withId(id) {
+    if (!id.startsWith("int_")) {
+      throw new Error('Interaction ID must start with "int_"');
+    }
+    this.interaction.id = id;
+    return this;
+  }
+  /**
+   * Set custom creation timestamp (use for testing/replay).
+   */
+  withCreatedAt(timestamp) {
+    this.interaction.createdAt = timestamp;
+    return this;
+  }
+  /**
+   * Build and return the Interaction.
+   *
+   * @throws Error if no participants have been added
+   * @returns The constructed Interaction
+   */
+  build() {
+    if (!this.interaction.participants?.length) {
+      throw new Error("Interaction must have at least one participant");
+    }
+    if (!("context" in this.interaction)) {
+      this.interaction.context = void 0;
+    }
+    return this.interaction;
+  }
+};
+function transitionStatus(interaction, newStatus) {
+  const updates = { status: newStatus };
+  if (newStatus === "active" && !interaction.startedAt) {
+    updates.startedAt = Date.now();
+  }
+  if (["completed", "failed", "cancelled"].includes(newStatus) && !interaction.completedAt) {
+    updates.completedAt = Date.now();
+  }
+  return { ...interaction, ...updates };
+}
+
+// ../../lib/terminals-tech/core/primitives/interaction-lifecycle.ts
+function buildLifecycleEvent(type, payload) {
+  return { type, payload };
+}
+function createInteractionWithEvents(input, options = {}) {
+  const type = input.type ?? "workflow";
+  const status = input.status ?? "initiated";
+  const builder = new InteractionBuilder(type);
+  if (input.id) {
+    builder.withId(input.id);
+  }
+  if (input.parentId) {
+    builder.withParent(input.parentId);
+  }
+  if (input.participants && input.participants.length > 0) {
+    input.participants.forEach((p) => builder.addParticipant(p.address, p.role, p.metadata));
+  } else {
+    throw new Error("Interaction must include at least one participant");
+  }
+  if (input.labels && input.labels.length > 0) {
+    builder.addLabel(...input.labels);
+  }
+  builder.withContext(input.context);
+  let interaction = builder.build();
+  const events = [];
+  const createdEvent = buildLifecycleEvent("interaction:created", {
+    interaction,
+    sequence: options.sequence
+  });
+  events.push(createdEvent);
+  if (status !== "initiated") {
+    const transitioned = transitionStatus(interaction, status);
+    const resolvedTimestamp = options.timestamp ?? (status === "active" ? transitioned.startedAt : ["completed", "failed", "cancelled"].includes(status) ? transitioned.completedAt : void 0) ?? Date.now();
+    const statusEvent = buildLifecycleEvent("interaction:status_changed", {
+      interactionId: transitioned.id,
+      from: interaction.status,
+      to: transitioned.status,
+      at: resolvedTimestamp,
+      sequence: options.sequence !== void 0 ? options.sequence + 1 : void 0
+    });
+    interaction = transitioned;
+    events.push(statusEvent);
+  }
+  return { interaction, events };
+}
+function transitionStatusWithEvent(interaction, newStatus, options = {}) {
+  const updated = transitionStatus(interaction, newStatus);
+  const resolvedTimestamp = options.timestamp ?? (newStatus === "active" ? updated.startedAt : ["completed", "failed", "cancelled"].includes(newStatus) ? updated.completedAt : void 0) ?? Date.now();
+  const event = buildLifecycleEvent("interaction:status_changed", {
+    interactionId: updated.id,
+    from: interaction.status,
+    to: updated.status,
+    at: resolvedTimestamp,
+    sequence: options.sequence
+  });
+  return { interaction: updated, event };
+}
+
+// ../../lib/terminals-tech/core/primitives/message.ts
+var VALID_LAYER_LEVELS = ["L1", "L2", "L3", "L4", "L5"];
+function isValidLayerLevel(value) {
+  return VALID_LAYER_LEVELS.includes(value);
+}
+function parseAddress(str) {
+  const parts = str.split(":");
+  if (parts.length < 3) {
+    throw new Error(`Invalid address format: ${str}. Expected {layer}:{nodeType}:{nodeId}`);
+  }
+  const layerCandidate = parts[0];
+  if (!isValidLayerLevel(layerCandidate)) {
+    throw new Error(
+      `Invalid layer level: "${layerCandidate}". Must be one of: ${VALID_LAYER_LEVELS.join(", ")}`
+    );
+  }
+  return {
+    layer: layerCandidate,
+    nodeType: parts[1],
+    nodeId: parts[2],
+    userId: parts[3]
+  };
+}
+function formatAddress(addr) {
+  const base = `${addr.layer}:${addr.nodeType}:${addr.nodeId}`;
+  return addr.userId ? `${base}:${addr.userId}` : base;
+}
+function createAddress(layer, nodeType, nodeId, userId) {
+  return { layer, nodeType, nodeId, userId };
+}
+var SDK_ADDRESSES = {
+  /** AXON kernel address */
+  KERNEL: createAddress("L3", "kernel", "v0"),
+  /** Orchestrator address */
+  ORCHESTRATOR: createAddress("L2", "orchestrator", "v0"),
+  /** Broadcast address (all nodes) */
+  BROADCAST: createAddress("L1", "broadcast", "*")
+};
+
+// ../../lib/terminals-tech/core/primitives/strings.ts
+function sanitizeTraceSegment(value, maxLen = 48) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, maxLen);
+}
+
+export {
+  createInteractionWithEvents,
+  transitionStatusWithEvent,
+  sanitizeTraceSegment,
+  parseAddress,
+  formatAddress,
+  createAddress
+};