@makaio/framework 1.0.0-dev-1779046984397

package/dist/types-t295YC6T.d.mts

@@ -0,0 +1,262 @@
+import { z } from "zod";
+
+//#region packages/rules/src/types.d.ts
+/**
+ * JSON primitive value supported by serialized rules.
+ */
+type JsonPrimitive = string | number | boolean | null;
+/**
+ * Scalar comparison value supported by field operators.
+ */
+type ScalarValue = JsonPrimitive;
+/**
+ * Leaf-level comparison against a single field value.
+ *
+ * Operator payloads are intentionally scalar-only for compatibility with the
+ * existing payload filter semantics.
+ */
+type FieldOperator = ScalarValue | {
+  $eq: ScalarValue;
+} | {
+  $ne: ScalarValue;
+} | {
+  $in: ScalarValue[];
+} | {
+  $nin: ScalarValue[];
+} | {
+  $exists: boolean;
+} | {
+  $startsWith: string;
+} | {
+  $endsWith: string;
+} | {
+  $glob: string;
+};
+/**
+ * A single field comparison against the evaluation context.
+ */
+interface FieldCondition {
+  /** Dot-notation path into the evaluation context. */
+  field: string;
+  /** Comparison to perform against the resolved field value. */
+  operator: FieldOperator;
+}
+/**
+ * Boolean AND across multiple child conditions.
+ */
+interface AndCondition {
+  /** Child conditions that must all evaluate truthy. */
+  $and: Condition[];
+}
+/**
+ * Boolean OR across multiple child conditions.
+ */
+interface OrCondition {
+  /** Child conditions where any truthy child matches. */
+  $or: Condition[];
+}
+/**
+ * Boolean negation of a child condition.
+ */
+interface NotCondition {
+  /** Child condition to negate. */
+  $not: Condition;
+}
+/**
+ * Jexl-backed expression condition evaluated against the full context.
+ */
+interface ExpressionCondition {
+  /** Expression string evaluated against the full context object. */
+  $expr: string;
+}
+/**
+ * Any condition supported by the rules engine.
+ */
+type Condition = FieldCondition | AndCondition | OrCondition | NotCondition | ExpressionCondition;
+//#endregion
+//#region packages/rules/src/schemas.d.ts
+/**
+ * Zod schema for any supported condition.
+ */
+declare const ConditionSchema: z.ZodType<Condition>;
+//#endregion
+//#region packages/services/core/src/context-rules/types.d.ts
+/**
+ * Default turn-context bucket used for rules that inject additional context.
+ */
+declare const DEFAULT_CONTEXT_RULE_TURN_CONTEXT_KEY = "contextRules";
+/**
+ * Allowlisted managed instruction files owned by Context Rules.
+ */
+declare const MANAGED_INSTRUCTION_FILE_TARGETS: readonly ["AGENTS.md", "CLAUDE.md", "GEMINI.md", "COPILOT.md", "CURSOR.md"];
+/**
+ * Base snapshot fields available from current runtime seams.
+ *
+ * Host-owned fields are added through declaration merging on
+ * {@link ContextSnapshotExtensions}.
+ */
+interface ContextSnapshotBase {
+  /** Current working directory for the active agent/runtime, when known. */
+  cwd?: string;
+  /** Adapter identifier for the active agent/runtime, when known. */
+  adapterId?: string;
+  /** Makaio session identifier, when the runtime is attached to a session. */
+  sessionId?: string;
+  /** Active agent identifier, when resolution is tied to a specific agent. */
+  agentId?: string;
+}
+/**
+ * Host-owned declaration merge target for snapshot enrichment.
+ *
+ * Augment `@makaio/services-core/context-rules` from host code rather than
+ * widening the root services-core module.
+ */
+interface ContextSnapshotExtensions {}
+/**
+ * Fully resolved snapshot shape used for condition evaluation and rendering.
+ */
+type ContextSnapshot = ContextSnapshotBase & ContextSnapshotExtensions;
+/**
+ * Allowlisted managed instruction file target.
+ */
+type ManagedInstructionFileTarget = (typeof MANAGED_INSTRUCTION_FILE_TARGETS)[number];
+/**
+ * Scope levels supported by persisted context rules.
+ */
+type ContextRuleScope = 'global' | 'project' | 'session';
+/**
+ * Any condition supported by context-rule resolution.
+ */
+type ContextRuleCondition = z.infer<typeof ConditionSchema>;
+/**
+ * Rule action that injects rendered content into turn context.
+ */
+interface TurnContextRuleAction {
+  /** Delivery channel for the rendered rule content. */
+  channel: 'turnContext';
+  /** Template content rendered against the resolved snapshot. */
+  content: string;
+  /** Optional turn-context bucket key. Defaults to `contextRules`. */
+  turnContextKey?: string;
+}
+/**
+ * Rule action that projects rendered content into a managed root file.
+ */
+interface FileContextRuleAction {
+  /** Delivery channel for the rendered rule content. */
+  channel: 'file';
+  /** Template content rendered against the resolved snapshot. */
+  content: string;
+  /** Managed instruction file that receives the rendered projection. */
+  fileTarget: ManagedInstructionFileTarget;
+}
+/**
+ * Supported context-rule action payloads.
+ */
+type ContextRuleAction = TurnContextRuleAction | FileContextRuleAction;
+/**
+ * Scope fields shared by rule inputs and persisted rule records.
+ */
+interface ContextRuleScopeFields {
+  /** Hierarchical scope deciding when the rule is a candidate. */
+  scope: ContextRuleScope;
+  /** Project identifier for project scope and optionally project-bound session scope. */
+  projectId?: string;
+  /** Session identifier for session-scoped rules. */
+  sessionId?: string;
+}
+/**
+ * Write payload for creating or updating a context rule.
+ */
+interface ContextRuleInput extends ContextRuleScopeFields {
+  /** Stable rule identifier. */
+  id: string;
+  /** Human-readable rule name. */
+  name: string;
+  /** Optional description for diagnostics or UI display. */
+  description?: string;
+  /** Predicate tree that decides whether the rule matches. */
+  condition: ContextRuleCondition;
+  /** Delivery action attached to matching rules. */
+  action: ContextRuleAction;
+  /** Deterministic ordering key for matching rules. */
+  priority: number;
+  /** Whether the rule is active during resolution. */
+  enabled: boolean;
+}
+/**
+ * Persisted context rule record.
+ */
+interface ContextRule extends ContextRuleInput {
+  /** Creation timestamp in Unix milliseconds. */
+  createdAt: number;
+  /** Last update timestamp in Unix milliseconds. */
+  updatedAt: number;
+}
+/**
+ * Scope-based candidate query for storage-tier listing.
+ */
+interface ContextRuleListQuery {
+  /** Optional project identifier used to include project-scoped candidates and disambiguate project-bound session rules. */
+  projectId?: string;
+  /** Optional session identifier used to include session-scoped candidates. */
+  sessionId?: string;
+}
+/**
+ * Normalized scope identity used for cache invalidation.
+ */
+interface ContextRuleScopeIdentity {
+  /** Hierarchical scope deciding when the rule is a candidate. */
+  scope: ContextRuleScope;
+  /** Project identifier normalized to `null` when not part of the scope key. */
+  projectId: string | null;
+  /** Session identifier normalized to `null` when not part of the scope key. */
+  sessionId: string | null;
+}
+/**
+ * Service request for resolving matching rules against the current runtime.
+ */
+type ContextRuleResolutionRequest = ContextSnapshotBase;
+/**
+ * A matched rule after template rendering.
+ */
+interface ResolvedContextRule {
+  /** Stable rule identifier. */
+  id: string;
+  /** Human-readable rule name. */
+  name: string;
+  /** Deterministic sort key preserved in the resolved output. */
+  priority: number;
+  /** Original action payload for the matching rule. */
+  action: ContextRuleAction;
+  /** Template-rendered content for the concrete snapshot. */
+  renderedContent: string;
+}
+/**
+ * Service response grouping matched rules by delivery channel.
+ */
+interface ResolvedContextRules {
+  /** Concrete snapshot used for evaluation and rendering. */
+  snapshot: ContextSnapshot;
+  /** Resolved turn-context entries grouped by bucket key. */
+  turnContext: Record<string, ResolvedContextRule[]>;
+  /** Resolved managed-file entries grouped by file target. */
+  files: Partial<Record<ManagedInstructionFileTarget, ResolvedContextRule[]>>;
+}
+/**
+ * Lifecycle event emitted whenever persisted context rules change.
+ */
+interface ContextRuleChangedEvent {
+  /** Rule identifier that changed. */
+  ruleId: string;
+  /** Type of storage mutation that occurred. */
+  changeType: 'created' | 'updated' | 'deleted';
+  /** Scope identity before the mutation, or `null` for newly created rules. */
+  previous: ContextRuleScopeIdentity | null;
+  /** Scope identity after the mutation, or `null` for deleted rules. */
+  current: ContextRuleScopeIdentity | null;
+  /** Mutation timestamp in Unix milliseconds. */
+  timestamp: number;
+}
+//#endregion
+export { ManagedInstructionFileTarget as _, ContextRuleInput as a, TurnContextRuleAction as b, ContextRuleScope as c, ContextSnapshot as d, ContextSnapshotBase as f, MANAGED_INSTRUCTION_FILE_TARGETS as g, FileContextRuleAction as h, ContextRuleCondition as i, ContextRuleScopeFields as l, DEFAULT_CONTEXT_RULE_TURN_CONTEXT_KEY as m, ContextRuleAction as n, ContextRuleListQuery as o, ContextSnapshotExtensions as p, ContextRuleChangedEvent as r, ContextRuleResolutionRequest as s, ContextRule as t, ContextRuleScopeIdentity as u, ResolvedContextRule as v, ResolvedContextRules as y };

package/dist/types-vNpkAe4Y.d.mts

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import { SessionMessage } from "@makaio/framework/contracts";
+
+//#region packages/services/core/src/session-editor/types.d.ts
+/**
+ * Category of pipeline action.
+ */
+declare const ActionCategorySchema: z.ZodEnum<{
+  compression: "compression";
+  extraction: "extraction";
+  transformation: "transformation";
+}>;
+type ActionCategory = z.infer<typeof ActionCategorySchema>;
+/**
+ * Result of a pipeline action - either transformed messages or a context JSON.
+ */
+declare const ActionResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+  kind: z.ZodLiteral<"messages">;
+  messages: z.ZodArray<z.ZodObject<{
+    messageId: z.ZodString;
+    turnId: z.ZodNullable<z.ZodString>;
+    sessionId: z.ZodString;
+    role: z.ZodEnum<{
+      user: "user";
+      assistant: "assistant";
+    }>;
+    contentText: z.ZodString;
+    blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"image">;
+      source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"base64">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"url">;
+        url: z.ZodString;
+        mimeType: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>], "type">;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"document">;
+      source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"base64">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"url">;
+        url: z.ZodString;
+        mimeType: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>], "type">;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"attachment">;
+      fileName: z.ZodString;
+      filePath: z.ZodString;
+      source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"base64">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"url">;
+        url: z.ZodString;
+        mimeType: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>], "type">;
+      displayName: z.ZodOptional<z.ZodString>;
+      attachmentType: z.ZodEnum<{
+        file: "file";
+        directory: "directory";
+      }>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"reasoning">;
+      content: z.ZodString;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"tool_call">;
+      toolCallId: z.ZodString;
+      name: z.ZodString;
+      args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"tool_output">;
+      toolCallId: z.ZodString;
+      output: z.ZodString;
+      isError: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], "type">>;
+    agentId: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodOptional<z.ZodString>;
+    adapterMessageId: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodNumber;
+    editOf: z.ZodOptional<z.ZodString>;
+    origin: z.ZodOptional<z.ZodEnum<{
+      text: "text";
+      voice: "voice";
+      compact: "compact";
+    }>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"context">;
+  json: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  tokenEstimate: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>]>;
+type ActionResult = z.infer<typeof ActionResultSchema>;
+/**
+ * Definition of a pipeline action that can be registered and executed.
+ */
+interface SessionEditorAction {
+  /** Unique identifier */
+  id: string;
+  /** Display label */
+  label: string;
+  /** Description shown in UI */
+  description: string;
+  /** Category for grouping in UI */
+  category: ActionCategory;
+  /** Execute the action on messages */
+  execute(messages: SessionMessage[], options?: Record<string, unknown>): Promise<ActionResult>;
+  /** Optional: estimate resulting token count */
+  estimateTokens?(messages: SessionMessage[]): Promise<number>;
+}
+/**
+ * Pipeline step configuration (action + options).
+ */
+interface PipelineStep {
+  actionId: string;
+  options?: Record<string, unknown>;
+}
+//#endregion
+export { PipelineStep as a, ActionResultSchema as i, ActionCategorySchema as n, SessionEditorAction as o, ActionResult as r, ActionCategory as t };