@nextera.one/axis-server-sdk 2.2.1 → 2.2.2

package/dist/idel/index.mjs

@@ -0,0 +1,279 @@
+// src/idel/idel.compiler.ts
+var IdelSchemaRegistry = class {
+  constructor() {
+    this.schemas = /* @__PURE__ */ new Map();
+    this.aliases = /* @__PURE__ */ new Map();
+  }
+  register(schema) {
+    this.schemas.set(schema.intent, schema);
+  }
+  registerAlias(alias, intent) {
+    this.aliases.set(alias.toLowerCase(), intent);
+  }
+  get(intent) {
+    return this.schemas.get(intent);
+  }
+  resolve(raw) {
+    const exact = this.schemas.get(raw);
+    if (exact) return exact;
+    const aliased = this.aliases.get(raw.toLowerCase());
+    if (aliased) return this.schemas.get(aliased);
+    const candidates = [...this.schemas.keys()].filter(
+      (k) => k.startsWith(raw + ".") || k.toLowerCase().includes(raw.toLowerCase())
+    );
+    if (candidates.length === 1) {
+      return this.schemas.get(candidates[0]);
+    }
+    return void 0;
+  }
+  /**
+   * Find all schemas that partially match the raw input.
+   * Returns scored candidates for ambiguity resolution.
+   */
+  findCandidates(raw) {
+    const normalized = raw.toLowerCase().trim();
+    const results = [];
+    for (const [key, schema] of this.schemas) {
+      let score = 0;
+      if (key === raw) {
+        score = 1;
+      } else if (key.toLowerCase() === normalized) {
+        score = 0.95;
+      } else if (this.aliases.get(normalized) === key) {
+        score = 0.9;
+      } else if (key.toLowerCase().startsWith(normalized)) {
+        score = 0.7;
+      } else if (key.toLowerCase().includes(normalized)) {
+        score = 0.5;
+      } else if (schema.tags?.some((t) => t.toLowerCase().includes(normalized))) {
+        score = 0.4;
+      } else if (schema.description.toLowerCase().includes(normalized)) {
+        score = 0.3;
+      }
+      if (score > 0) {
+        results.push({ schema, score });
+      }
+    }
+    return results.sort((a, b) => b.score - a.score);
+  }
+  list() {
+    return [...this.schemas.values()];
+  }
+};
+var IdelCompiler = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  /**
+   * Compile a raw intent proposal into a validated, executable structure.
+   */
+  compile(proposal) {
+    const errors = [];
+    const candidates = this.registry.findCandidates(proposal.raw);
+    if (candidates.length === 0) {
+      return {
+        ok: false,
+        errors: [{
+          code: "IDEL_UNKNOWN_INTENT",
+          message: `No intent found matching '${proposal.raw}'`
+        }]
+      };
+    }
+    const best = candidates[0];
+    const schema = best.schema;
+    const alternatives = candidates.slice(1, 4).filter((c) => c.score >= 0.3).map((c) => ({
+      intent: c.schema.intent,
+      confidence: c.score,
+      reason: c.schema.description
+    }));
+    const constraints = [];
+    const clarifications = [];
+    const params = { ...proposal.params };
+    for (const paramSchema of schema.params) {
+      const value = params[paramSchema.name];
+      if (paramSchema.required && value === void 0) {
+        if (paramSchema.default !== void 0) {
+          params[paramSchema.name] = paramSchema.default;
+          constraints.push({
+            kind: "required_param",
+            field: paramSchema.name,
+            description: `Defaulted to ${JSON.stringify(paramSchema.default)}`,
+            satisfied: true,
+            value: paramSchema.default
+          });
+        } else {
+          constraints.push({
+            kind: "required_param",
+            field: paramSchema.name,
+            description: `Required parameter '${paramSchema.name}' is missing`,
+            satisfied: false
+          });
+          clarifications.push({
+            id: `clarify_${paramSchema.name}`,
+            question: paramSchema.description ?? `What is the ${paramSchema.name}?`,
+            field: paramSchema.name,
+            options: paramSchema.enum?.map(String),
+            required: true
+          });
+        }
+        continue;
+      }
+      if (value === void 0) continue;
+      const typeValid = validateType(value, paramSchema.type);
+      constraints.push({
+        kind: "type_check",
+        field: paramSchema.name,
+        description: `Must be ${paramSchema.type}`,
+        satisfied: typeValid,
+        value,
+        expected: paramSchema.type
+      });
+      if (!typeValid) {
+        errors.push({
+          code: "IDEL_TYPE_ERROR",
+          message: `Parameter '${paramSchema.name}' must be ${paramSchema.type}, got ${typeof value}`,
+          field: paramSchema.name
+        });
+      }
+      if (paramSchema.min !== void 0 || paramSchema.max !== void 0) {
+        const numVal = typeof value === "number" ? value : Number(value);
+        const inRange = (paramSchema.min === void 0 || numVal >= paramSchema.min) && (paramSchema.max === void 0 || numVal <= paramSchema.max);
+        constraints.push({
+          kind: "range",
+          field: paramSchema.name,
+          description: `Must be between ${paramSchema.min ?? "-\u221E"} and ${paramSchema.max ?? "\u221E"}`,
+          satisfied: inRange,
+          value: numVal
+        });
+      }
+      if (paramSchema.pattern) {
+        const matches = new RegExp(paramSchema.pattern).test(String(value));
+        constraints.push({
+          kind: "pattern",
+          field: paramSchema.name,
+          description: `Must match ${paramSchema.pattern}`,
+          satisfied: matches,
+          value,
+          expected: paramSchema.pattern
+        });
+      }
+      if (paramSchema.enum) {
+        const inEnum = paramSchema.enum.some(
+          (e) => JSON.stringify(e) === JSON.stringify(value)
+        );
+        constraints.push({
+          kind: "custom",
+          field: paramSchema.name,
+          description: `Must be one of: ${paramSchema.enum.join(", ")}`,
+          satisfied: inEnum,
+          value,
+          expected: paramSchema.enum
+        });
+      }
+    }
+    const risk = assessRisk(schema, proposal, constraints);
+    const unsatisfied = constraints.filter((c) => !c.satisfied);
+    const needsClarification = clarifications.length > 0;
+    let confidence = best.score;
+    if (unsatisfied.length > 0) {
+      confidence *= 1 - unsatisfied.length / Math.max(constraints.length, 1) * 0.5;
+    }
+    if (errors.length > 0) {
+      confidence *= 0.5;
+    }
+    const compiled = {
+      intent: schema.intent,
+      actor_id: proposal.actor_id,
+      target: proposal.target,
+      params,
+      constraints,
+      confidence,
+      alternatives,
+      needs_clarification: needsClarification,
+      clarifications,
+      expected_outcome: schema.description,
+      fallback: schema.related?.[0],
+      risk,
+      metadata: {
+        schema_intent: schema.intent,
+        resolved_from: proposal.raw,
+        has_side_effects: schema.has_side_effects,
+        reversible: schema.reversible
+      }
+    };
+    return {
+      ok: errors.length === 0 && !needsClarification,
+      compiled,
+      errors
+    };
+  }
+  /**
+   * Apply clarification answers and re-compile.
+   */
+  applyClarifications(compiled, answers) {
+    const proposal = {
+      raw: compiled.intent,
+      actor_id: compiled.actor_id,
+      target: compiled.target,
+      params: { ...compiled.params, ...answers }
+    };
+    return this.compile(proposal);
+  }
+};
+function validateType(value, expectedType) {
+  switch (expectedType) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    case "array":
+      return Array.isArray(value);
+    default:
+      return true;
+  }
+}
+function assessRisk(schema, proposal, constraints) {
+  const factors = [];
+  let score = 0;
+  const baseRiskMap = {
+    none: 0,
+    low: 0.1,
+    medium: 0.3,
+    high: 0.6,
+    critical: 0.9
+  };
+  score = baseRiskMap[schema.risk_level] ?? 0;
+  if (schema.risk_level !== "none") {
+    factors.push(`Base risk: ${schema.risk_level}`);
+  }
+  if (schema.has_side_effects) {
+    score += 0.1;
+    factors.push("Has side effects");
+  }
+  if (!schema.reversible) {
+    score += 0.1;
+    factors.push("Not reversible");
+  }
+  const failed = constraints.filter((c) => !c.satisfied);
+  if (failed.length > 0) {
+    score += 0.05 * failed.length;
+    factors.push(`${failed.length} unsatisfied constraint(s)`);
+  }
+  score = Math.min(score, 1);
+  let level;
+  if (score <= 0) level = "none";
+  else if (score <= 0.2) level = "low";
+  else if (score <= 0.5) level = "medium";
+  else if (score <= 0.8) level = "high";
+  else level = "critical";
+  return { level, score, factors };
+}
+export {
+  IdelCompiler,
+  IdelSchemaRegistry
+};
+//# sourceMappingURL=index.mjs.map

package/dist/idel/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/idel/idel.compiler.ts"],"sourcesContent":["/**\n * IDEL Compiler — Intent Description & Execution Language\n *\n * Compiles raw intent proposals into validated, executable structures.\n *\n * Pipeline:\n *   1. Resolve: match raw input to a known intent schema\n *   2. Validate: check all required params and constraints\n *   3. Assess risk: evaluate intent risk level\n *   4. Generate clarifications: if ambiguous or incomplete\n *   5. Output: CompiledIntent ready for AXIS execution\n */\n\nimport type {\n  AlternativeIntent,\n  ClarificationQuestion,\n  CompilationError,\n  CompilationResult,\n  CompiledIntent,\n  IntentConstraint,\n  IntentParamSchema,\n  IntentProposal,\n  IntentRisk,\n  IntentSchema,\n  RiskLevel,\n} from './idel.types';\n\n// ────────────────────────────────────────────────────────────────────────────\n// Schema Registry\n// ────────────────────────────────────────────────────────────────────────────\n\nexport class IdelSchemaRegistry {\n  private schemas = new Map<string, IntentSchema>();\n  private aliases = new Map<string, string>();\n\n  register(schema: IntentSchema): void {\n    this.schemas.set(schema.intent, schema);\n  }\n\n  registerAlias(alias: string, intent: string): void {\n    this.aliases.set(alias.toLowerCase(), intent);\n  }\n\n  get(intent: string): IntentSchema | undefined {\n    return this.schemas.get(intent);\n  }\n\n  resolve(raw: string): IntentSchema | undefined {\n    // Exact match\n    const exact = this.schemas.get(raw);\n    if (exact) return exact;\n\n    // Alias match\n    const aliased = this.aliases.get(raw.toLowerCase());\n    if (aliased) return this.schemas.get(aliased);\n\n    // Prefix match (e.g., \"payment\" → \"payment.create\")\n    const candidates = [...this.schemas.keys()].filter(\n      (k) => k.startsWith(raw + '.') || k.toLowerCase().includes(raw.toLowerCase()),\n    );\n    if (candidates.length === 1) {\n      return this.schemas.get(candidates[0]);\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Find all schemas that partially match the raw input.\n   * Returns scored candidates for ambiguity resolution.\n   */\n  findCandidates(raw: string): Array<{ schema: IntentSchema; score: number }> {\n    const normalized = raw.toLowerCase().trim();\n    const results: Array<{ schema: IntentSchema; score: number }> = [];\n\n    for (const [key, schema] of this.schemas) {\n      let score = 0;\n\n      // Exact match\n      if (key === raw) {\n        score = 1.0;\n      }\n      // Case-insensitive exact\n      else if (key.toLowerCase() === normalized) {\n        score = 0.95;\n      }\n      // Alias match\n      else if (this.aliases.get(normalized) === key) {\n        score = 0.9;\n      }\n      // Prefix match\n      else if (key.toLowerCase().startsWith(normalized)) {\n        score = 0.7;\n      }\n      // Contains match\n      else if (key.toLowerCase().includes(normalized)) {\n        score = 0.5;\n      }\n      // Tag match\n      else if (schema.tags?.some((t) => t.toLowerCase().includes(normalized))) {\n        score = 0.4;\n      }\n      // Description match\n      else if (schema.description.toLowerCase().includes(normalized)) {\n        score = 0.3;\n      }\n\n      if (score > 0) {\n        results.push({ schema, score });\n      }\n    }\n\n    return results.sort((a, b) => b.score - a.score);\n  }\n\n  list(): IntentSchema[] {\n    return [...this.schemas.values()];\n  }\n}\n\n// ────────────────────────────────────────────────────────────────────────────\n// IDEL Compiler\n// ────────────────────────────────────────────────────────────────────────────\n\nexport class IdelCompiler {\n  constructor(private readonly registry: IdelSchemaRegistry) {}\n\n  /**\n   * Compile a raw intent proposal into a validated, executable structure.\n   */\n  compile(proposal: IntentProposal): CompilationResult {\n    const errors: CompilationError[] = [];\n\n    // 1. Resolve intent\n    const candidates = this.registry.findCandidates(proposal.raw);\n    if (candidates.length === 0) {\n      return {\n        ok: false,\n        errors: [{\n          code: 'IDEL_UNKNOWN_INTENT',\n          message: `No intent found matching '${proposal.raw}'`,\n        }],\n      };\n    }\n\n    const best = candidates[0];\n    const schema = best.schema;\n\n    // 2. Build alternatives\n    const alternatives: AlternativeIntent[] = candidates\n      .slice(1, 4)\n      .filter((c) => c.score >= 0.3)\n      .map((c) => ({\n        intent: c.schema.intent,\n        confidence: c.score,\n        reason: c.schema.description,\n      }));\n\n    // 3. Validate parameters\n    const constraints: IntentConstraint[] = [];\n    const clarifications: ClarificationQuestion[] = [];\n    const params = { ...proposal.params };\n\n    for (const paramSchema of schema.params) {\n      const value = params[paramSchema.name];\n\n      // Required check\n      if (paramSchema.required && value === undefined) {\n        if (paramSchema.default !== undefined) {\n          params[paramSchema.name] = paramSchema.default;\n          constraints.push({\n            kind: 'required_param',\n            field: paramSchema.name,\n            description: `Defaulted to ${JSON.stringify(paramSchema.default)}`,\n            satisfied: true,\n            value: paramSchema.default,\n          });\n        } else {\n          constraints.push({\n            kind: 'required_param',\n            field: paramSchema.name,\n            description: `Required parameter '${paramSchema.name}' is missing`,\n            satisfied: false,\n          });\n          clarifications.push({\n            id: `clarify_${paramSchema.name}`,\n            question: paramSchema.description ?? `What is the ${paramSchema.name}?`,\n            field: paramSchema.name,\n            options: paramSchema.enum?.map(String),\n            required: true,\n          });\n        }\n        continue;\n      }\n\n      if (value === undefined) continue;\n\n      // Type check\n      const typeValid = validateType(value, paramSchema.type);\n      constraints.push({\n        kind: 'type_check',\n        field: paramSchema.name,\n        description: `Must be ${paramSchema.type}`,\n        satisfied: typeValid,\n        value,\n        expected: paramSchema.type,\n      });\n      if (!typeValid) {\n        errors.push({\n          code: 'IDEL_TYPE_ERROR',\n          message: `Parameter '${paramSchema.name}' must be ${paramSchema.type}, got ${typeof value}`,\n          field: paramSchema.name,\n        });\n      }\n\n      // Range check\n      if (paramSchema.min !== undefined || paramSchema.max !== undefined) {\n        const numVal = typeof value === 'number' ? value : Number(value);\n        const inRange =\n          (paramSchema.min === undefined || numVal >= paramSchema.min) &&\n          (paramSchema.max === undefined || numVal <= paramSchema.max);\n        constraints.push({\n          kind: 'range',\n          field: paramSchema.name,\n          description: `Must be between ${paramSchema.min ?? '-∞'} and ${paramSchema.max ?? '∞'}`,\n          satisfied: inRange,\n          value: numVal,\n        });\n      }\n\n      // Pattern check\n      if (paramSchema.pattern) {\n        const matches = new RegExp(paramSchema.pattern).test(String(value));\n        constraints.push({\n          kind: 'pattern',\n          field: paramSchema.name,\n          description: `Must match ${paramSchema.pattern}`,\n          satisfied: matches,\n          value,\n          expected: paramSchema.pattern,\n        });\n      }\n\n      // Enum check\n      if (paramSchema.enum) {\n        const inEnum = paramSchema.enum.some(\n          (e) => JSON.stringify(e) === JSON.stringify(value),\n        );\n        constraints.push({\n          kind: 'custom',\n          field: paramSchema.name,\n          description: `Must be one of: ${paramSchema.enum.join(', ')}`,\n          satisfied: inEnum,\n          value,\n          expected: paramSchema.enum,\n        });\n      }\n    }\n\n    // 4. Assess risk\n    const risk = assessRisk(schema, proposal, constraints);\n\n    // 5. Compute confidence\n    const unsatisfied = constraints.filter((c) => !c.satisfied);\n    const needsClarification = clarifications.length > 0;\n    let confidence = best.score;\n    if (unsatisfied.length > 0) {\n      confidence *= 1 - (unsatisfied.length / Math.max(constraints.length, 1)) * 0.5;\n    }\n    if (errors.length > 0) {\n      confidence *= 0.5;\n    }\n\n    const compiled: CompiledIntent = {\n      intent: schema.intent,\n      actor_id: proposal.actor_id,\n      target: proposal.target,\n      params,\n      constraints,\n      confidence,\n      alternatives,\n      needs_clarification: needsClarification,\n      clarifications,\n      expected_outcome: schema.description,\n      fallback: schema.related?.[0],\n      risk,\n      metadata: {\n        schema_intent: schema.intent,\n        resolved_from: proposal.raw,\n        has_side_effects: schema.has_side_effects,\n        reversible: schema.reversible,\n      },\n    };\n\n    return {\n      ok: errors.length === 0 && !needsClarification,\n      compiled,\n      errors,\n    };\n  }\n\n  /**\n   * Apply clarification answers and re-compile.\n   */\n  applyClarifications(\n    compiled: CompiledIntent,\n    answers: Record<string, unknown>,\n  ): CompilationResult {\n    const proposal: IntentProposal = {\n      raw: compiled.intent,\n      actor_id: compiled.actor_id,\n      target: compiled.target,\n      params: { ...compiled.params, ...answers },\n    };\n    return this.compile(proposal);\n  }\n}\n\n// ────────────────────────────────────────────────────────────────────────────\n// Helpers\n// ────────────────────────────────────────────────────────────────────────────\n\nfunction validateType(value: unknown, expectedType: IntentParamSchema['type']): boolean {\n  switch (expectedType) {\n    case 'string':\n      return typeof value === 'string';\n    case 'number':\n      return typeof value === 'number' && Number.isFinite(value);\n    case 'boolean':\n      return typeof value === 'boolean';\n    case 'object':\n      return typeof value === 'object' && value !== null && !Array.isArray(value);\n    case 'array':\n      return Array.isArray(value);\n    default:\n      return true;\n  }\n}\n\nfunction assessRisk(\n  schema: IntentSchema,\n  proposal: IntentProposal,\n  constraints: IntentConstraint[],\n): IntentRisk {\n  const factors: string[] = [];\n  let score = 0;\n\n  // Base risk from schema\n  const baseRiskMap: Record<RiskLevel, number> = {\n    none: 0,\n    low: 0.1,\n    medium: 0.3,\n    high: 0.6,\n    critical: 0.9,\n  };\n  score = baseRiskMap[schema.risk_level] ?? 0;\n  if (schema.risk_level !== 'none') {\n    factors.push(`Base risk: ${schema.risk_level}`);\n  }\n\n  // Side effects increase risk\n  if (schema.has_side_effects) {\n    score += 0.1;\n    factors.push('Has side effects');\n  }\n\n  // Irreversible actions increase risk\n  if (!schema.reversible) {\n    score += 0.1;\n    factors.push('Not reversible');\n  }\n\n  // Failed constraints increase risk\n  const failed = constraints.filter((c) => !c.satisfied);\n  if (failed.length > 0) {\n    score += 0.05 * failed.length;\n    factors.push(`${failed.length} unsatisfied constraint(s)`);\n  }\n\n  // Clamp\n  score = Math.min(score, 1.0);\n\n  let level: RiskLevel;\n  if (score <= 0) level = 'none';\n  else if (score <= 0.2) level = 'low';\n  else if (score <= 0.5) level = 'medium';\n  else if (score <= 0.8) level = 'high';\n  else level = 'critical';\n\n  return { level, score, factors };\n}\n"],"mappings":";AA+BO,IAAM,qBAAN,MAAyB;AAAA,EAAzB;AACL,SAAQ,UAAU,oBAAI,IAA0B;AAChD,SAAQ,UAAU,oBAAI,IAAoB;AAAA;AAAA,EAE1C,SAAS,QAA4B;AACnC,SAAK,QAAQ,IAAI,OAAO,QAAQ,MAAM;AAAA,EACxC;AAAA,EAEA,cAAc,OAAe,QAAsB;AACjD,SAAK,QAAQ,IAAI,MAAM,YAAY,GAAG,MAAM;AAAA,EAC9C;AAAA,EAEA,IAAI,QAA0C;AAC5C,WAAO,KAAK,QAAQ,IAAI,MAAM;AAAA,EAChC;AAAA,EAEA,QAAQ,KAAuC;AAE7C,UAAM,QAAQ,KAAK,QAAQ,IAAI,GAAG;AAClC,QAAI,MAAO,QAAO;AAGlB,UAAM,UAAU,KAAK,QAAQ,IAAI,IAAI,YAAY,CAAC;AAClD,QAAI,QAAS,QAAO,KAAK,QAAQ,IAAI,OAAO;AAG5C,UAAM,aAAa,CAAC,GAAG,KAAK,QAAQ,KAAK,CAAC,EAAE;AAAA,MAC1C,CAAC,MAAM,EAAE,WAAW,MAAM,GAAG,KAAK,EAAE,YAAY,EAAE,SAAS,IAAI,YAAY,CAAC;AAAA,IAC9E;AACA,QAAI,WAAW,WAAW,GAAG;AAC3B,aAAO,KAAK,QAAQ,IAAI,WAAW,CAAC,CAAC;AAAA,IACvC;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,eAAe,KAA6D;AAC1E,UAAM,aAAa,IAAI,YAAY,EAAE,KAAK;AAC1C,UAAM,UAA0D,CAAC;AAEjE,eAAW,CAAC,KAAK,MAAM,KAAK,KAAK,SAAS;AACxC,UAAI,QAAQ;AAGZ,UAAI,QAAQ,KAAK;AACf,gBAAQ;AAAA,MACV,WAES,IAAI,YAAY,MAAM,YAAY;AACzC,gBAAQ;AAAA,MACV,WAES,KAAK,QAAQ,IAAI,UAAU,MAAM,KAAK;AAC7C,gBAAQ;AAAA,MACV,WAES,IAAI,YAAY,EAAE,WAAW,UAAU,GAAG;AACjD,gBAAQ;AAAA,MACV,WAES,IAAI,YAAY,EAAE,SAAS,UAAU,GAAG;AAC/C,gBAAQ;AAAA,MACV,WAES,OAAO,MAAM,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,UAAU,CAAC,GAAG;AACvE,gBAAQ;AAAA,MACV,WAES,OAAO,YAAY,YAAY,EAAE,SAAS,UAAU,GAAG;AAC9D,gBAAQ;AAAA,MACV;AAEA,UAAI,QAAQ,GAAG;AACb,gBAAQ,KAAK,EAAE,QAAQ,MAAM,CAAC;AAAA,MAChC;AAAA,IACF;AAEA,WAAO,QAAQ,KAAK,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK;AAAA,EACjD;AAAA,EAEA,OAAuB;AACrB,WAAO,CAAC,GAAG,KAAK,QAAQ,OAAO,CAAC;AAAA,EAClC;AACF;AAMO,IAAM,eAAN,MAAmB;AAAA,EACxB,YAA6B,UAA8B;AAA9B;AAAA,EAA+B;AAAA;AAAA;AAAA;AAAA,EAK5D,QAAQ,UAA6C;AACnD,UAAM,SAA6B,CAAC;AAGpC,UAAM,aAAa,KAAK,SAAS,eAAe,SAAS,GAAG;AAC5D,QAAI,WAAW,WAAW,GAAG;AAC3B,aAAO;AAAA,QACL,IAAI;AAAA,QACJ,QAAQ,CAAC;AAAA,UACP,MAAM;AAAA,UACN,SAAS,6BAA6B,SAAS,GAAG;AAAA,QACpD,CAAC;AAAA,MACH;AAAA,IACF;AAEA,UAAM,OAAO,WAAW,CAAC;AACzB,UAAM,SAAS,KAAK;AAGpB,UAAM,eAAoC,WACvC,MAAM,GAAG,CAAC,EACV,OAAO,CAAC,MAAM,EAAE,SAAS,GAAG,EAC5B,IAAI,CAAC,OAAO;AAAA,MACX,QAAQ,EAAE,OAAO;AAAA,MACjB,YAAY,EAAE;AAAA,MACd,QAAQ,EAAE,OAAO;AAAA,IACnB,EAAE;AAGJ,UAAM,cAAkC,CAAC;AACzC,UAAM,iBAA0C,CAAC;AACjD,UAAM,SAAS,EAAE,GAAG,SAAS,OAAO;AAEpC,eAAW,eAAe,OAAO,QAAQ;AACvC,YAAM,QAAQ,OAAO,YAAY,IAAI;AAGrC,UAAI,YAAY,YAAY,UAAU,QAAW;AAC/C,YAAI,YAAY,YAAY,QAAW;AACrC,iBAAO,YAAY,IAAI,IAAI,YAAY;AACvC,sBAAY,KAAK;AAAA,YACf,MAAM;AAAA,YACN,OAAO,YAAY;AAAA,YACnB,aAAa,gBAAgB,KAAK,UAAU,YAAY,OAAO,CAAC;AAAA,YAChE,WAAW;AAAA,YACX,OAAO,YAAY;AAAA,UACrB,CAAC;AAAA,QACH,OAAO;AACL,sBAAY,KAAK;AAAA,YACf,MAAM;AAAA,YACN,OAAO,YAAY;AAAA,YACnB,aAAa,uBAAuB,YAAY,IAAI;AAAA,YACpD,WAAW;AAAA,UACb,CAAC;AACD,yBAAe,KAAK;AAAA,YAClB,IAAI,WAAW,YAAY,IAAI;AAAA,YAC/B,UAAU,YAAY,eAAe,eAAe,YAAY,IAAI;AAAA,YACpE,OAAO,YAAY;AAAA,YACnB,SAAS,YAAY,MAAM,IAAI,MAAM;AAAA,YACrC,UAAU;AAAA,UACZ,CAAC;AAAA,QACH;AACA;AAAA,MACF;AAEA,UAAI,UAAU,OAAW;AAGzB,YAAM,YAAY,aAAa,OAAO,YAAY,IAAI;AACtD,kBAAY,KAAK;AAAA,QACf,MAAM;AAAA,QACN,OAAO,YAAY;AAAA,QACnB,aAAa,WAAW,YAAY,IAAI;AAAA,QACxC,WAAW;AAAA,QACX;AAAA,QACA,UAAU,YAAY;AAAA,MACxB,CAAC;AACD,UAAI,CAAC,WAAW;AACd,eAAO,KAAK;AAAA,UACV,MAAM;AAAA,UACN,SAAS,cAAc,YAAY,IAAI,aAAa,YAAY,IAAI,SAAS,OAAO,KAAK;AAAA,UACzF,OAAO,YAAY;AAAA,QACrB,CAAC;AAAA,MACH;AAGA,UAAI,YAAY,QAAQ,UAAa,YAAY,QAAQ,QAAW;AAClE,cAAM,SAAS,OAAO,UAAU,WAAW,QAAQ,OAAO,KAAK;AAC/D,cAAM,WACH,YAAY,QAAQ,UAAa,UAAU,YAAY,SACvD,YAAY,QAAQ,UAAa,UAAU,YAAY;AAC1D,oBAAY,KAAK;AAAA,UACf,MAAM;AAAA,UACN,OAAO,YAAY;AAAA,UACnB,aAAa,mBAAmB,YAAY,OAAO,SAAI,QAAQ,YAAY,OAAO,QAAG;AAAA,UACrF,WAAW;AAAA,UACX,OAAO;AAAA,QACT,CAAC;AAAA,MACH;AAGA,UAAI,YAAY,SAAS;AACvB,cAAM,UAAU,IAAI,OAAO,YAAY,OAAO,EAAE,KAAK,OAAO,KAAK,CAAC;AAClE,oBAAY,KAAK;AAAA,UACf,MAAM;AAAA,UACN,OAAO,YAAY;AAAA,UACnB,aAAa,cAAc,YAAY,OAAO;AAAA,UAC9C,WAAW;AAAA,UACX;AAAA,UACA,UAAU,YAAY;AAAA,QACxB,CAAC;AAAA,MACH;AAGA,UAAI,YAAY,MAAM;AACpB,cAAM,SAAS,YAAY,KAAK;AAAA,UAC9B,CAAC,MAAM,KAAK,UAAU,CAAC,MAAM,KAAK,UAAU,KAAK;AAAA,QACnD;AACA,oBAAY,KAAK;AAAA,UACf,MAAM;AAAA,UACN,OAAO,YAAY;AAAA,UACnB,aAAa,mBAAmB,YAAY,KAAK,KAAK,IAAI,CAAC;AAAA,UAC3D,WAAW;AAAA,UACX;AAAA,UACA,UAAU,YAAY;AAAA,QACxB,CAAC;AAAA,MACH;AAAA,IACF;AAGA,UAAM,OAAO,WAAW,QAAQ,UAAU,WAAW;AAGrD,UAAM,cAAc,YAAY,OAAO,CAAC,MAAM,CAAC,EAAE,SAAS;AAC1D,UAAM,qBAAqB,eAAe,SAAS;AACnD,QAAI,aAAa,KAAK;AACtB,QAAI,YAAY,SAAS,GAAG;AAC1B,oBAAc,IAAK,YAAY,SAAS,KAAK,IAAI,YAAY,QAAQ,CAAC,IAAK;AAAA,IAC7E;AACA,QAAI,OAAO,SAAS,GAAG;AACrB,oBAAc;AAAA,IAChB;AAEA,UAAM,WAA2B;AAAA,MAC/B,QAAQ,OAAO;AAAA,MACf,UAAU,SAAS;AAAA,MACnB,QAAQ,SAAS;AAAA,MACjB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,qBAAqB;AAAA,MACrB;AAAA,MACA,kBAAkB,OAAO;AAAA,MACzB,UAAU,OAAO,UAAU,CAAC;AAAA,MAC5B;AAAA,MACA,UAAU;AAAA,QACR,eAAe,OAAO;AAAA,QACtB,eAAe,SAAS;AAAA,QACxB,kBAAkB,OAAO;AAAA,QACzB,YAAY,OAAO;AAAA,MACrB;AAAA,IACF;AAEA,WAAO;AAAA,MACL,IAAI,OAAO,WAAW,KAAK,CAAC;AAAA,MAC5B;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,oBACE,UACA,SACmB;AACnB,UAAM,WAA2B;AAAA,MAC/B,KAAK,SAAS;AAAA,MACd,UAAU,SAAS;AAAA,MACnB,QAAQ,SAAS;AAAA,MACjB,QAAQ,EAAE,GAAG,SAAS,QAAQ,GAAG,QAAQ;AAAA,IAC3C;AACA,WAAO,KAAK,QAAQ,QAAQ;AAAA,EAC9B;AACF;AAMA,SAAS,aAAa,OAAgB,cAAkD;AACtF,UAAQ,cAAc;AAAA,IACpB,KAAK;AACH,aAAO,OAAO,UAAU;AAAA,IAC1B,KAAK;AACH,aAAO,OAAO,UAAU,YAAY,OAAO,SAAS,KAAK;AAAA,IAC3D,KAAK;AACH,aAAO,OAAO,UAAU;AAAA,IAC1B,KAAK;AACH,aAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAAA,IAC5E,KAAK;AACH,aAAO,MAAM,QAAQ,KAAK;AAAA,IAC5B;AACE,aAAO;AAAA,EACX;AACF;AAEA,SAAS,WACP,QACA,UACA,aACY;AACZ,QAAM,UAAoB,CAAC;AAC3B,MAAI,QAAQ;AAGZ,QAAM,cAAyC;AAAA,IAC7C,MAAM;AAAA,IACN,KAAK;AAAA,IACL,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,UAAU;AAAA,EACZ;AACA,UAAQ,YAAY,OAAO,UAAU,KAAK;AAC1C,MAAI,OAAO,eAAe,QAAQ;AAChC,YAAQ,KAAK,cAAc,OAAO,UAAU,EAAE;AAAA,EAChD;AAGA,MAAI,OAAO,kBAAkB;AAC3B,aAAS;AACT,YAAQ,KAAK,kBAAkB;AAAA,EACjC;AAGA,MAAI,CAAC,OAAO,YAAY;AACtB,aAAS;AACT,YAAQ,KAAK,gBAAgB;AAAA,EAC/B;AAGA,QAAM,SAAS,YAAY,OAAO,CAAC,MAAM,CAAC,EAAE,SAAS;AACrD,MAAI,OAAO,SAAS,GAAG;AACrB,aAAS,OAAO,OAAO;AACvB,YAAQ,KAAK,GAAG,OAAO,MAAM,4BAA4B;AAAA,EAC3D;AAGA,UAAQ,KAAK,IAAI,OAAO,CAAG;AAE3B,MAAI;AACJ,MAAI,SAAS,EAAG,SAAQ;AAAA,WACf,SAAS,IAAK,SAAQ;AAAA,WACtB,SAAS,IAAK,SAAQ;AAAA,WACtB,SAAS,IAAK,SAAQ;AAAA,MAC1B,SAAQ;AAEb,SAAO,EAAE,OAAO,OAAO,QAAQ;AACjC;","names":[]}

package/dist/idel.types-DuUAcOnQ.d.mts

@@ -0,0 +1,83 @@
+interface IntentProposal {
+    raw: string;
+    actor_id: string;
+    target?: string;
+    params?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+}
+interface CompiledIntent {
+    intent: string;
+    actor_id: string;
+    target?: string;
+    params: Record<string, unknown>;
+    constraints: IntentConstraint[];
+    confidence: number;
+    alternatives: AlternativeIntent[];
+    needs_clarification: boolean;
+    clarifications: ClarificationQuestion[];
+    expected_outcome?: string;
+    fallback?: string;
+    risk: IntentRisk;
+    metadata: Record<string, unknown>;
+}
+type ConstraintKind = 'required_param' | 'type_check' | 'range' | 'pattern' | 'temporal' | 'spatial' | 'authority' | 'safety' | 'custom';
+interface IntentConstraint {
+    kind: ConstraintKind;
+    field: string;
+    description: string;
+    satisfied: boolean;
+    value?: unknown;
+    expected?: unknown;
+}
+interface AlternativeIntent {
+    intent: string;
+    confidence: number;
+    reason: string;
+}
+interface ClarificationQuestion {
+    id: string;
+    question: string;
+    field: string;
+    options?: string[];
+    required: boolean;
+}
+type RiskLevel = 'none' | 'low' | 'medium' | 'high' | 'critical';
+interface IntentRisk {
+    level: RiskLevel;
+    score: number;
+    factors: string[];
+}
+interface IntentParamSchema {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    required: boolean;
+    description?: string;
+    default?: unknown;
+    pattern?: string;
+    min?: number;
+    max?: number;
+    enum?: unknown[];
+}
+interface IntentSchema {
+    intent: string;
+    description: string;
+    params: IntentParamSchema[];
+    required_scopes?: string[];
+    risk_level: RiskLevel;
+    has_side_effects: boolean;
+    reversible: boolean;
+    related?: string[];
+    tags?: string[];
+}
+interface CompilationResult {
+    ok: boolean;
+    compiled?: CompiledIntent;
+    errors: CompilationError[];
+}
+interface CompilationError {
+    code: string;
+    message: string;
+    field?: string;
+}
+
+export type { AlternativeIntent as A, ClarificationQuestion as C, IntentConstraint as I, RiskLevel as R, CompilationError as a, CompilationResult as b, CompiledIntent as c, ConstraintKind as d, IntentParamSchema as e, IntentProposal as f, IntentRisk as g, IntentSchema as h };

package/dist/idel.types-DuUAcOnQ.d.ts

@@ -0,0 +1,83 @@
+interface IntentProposal {
+    raw: string;
+    actor_id: string;
+    target?: string;
+    params?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+}
+interface CompiledIntent {
+    intent: string;
+    actor_id: string;
+    target?: string;
+    params: Record<string, unknown>;
+    constraints: IntentConstraint[];
+    confidence: number;
+    alternatives: AlternativeIntent[];
+    needs_clarification: boolean;
+    clarifications: ClarificationQuestion[];
+    expected_outcome?: string;
+    fallback?: string;
+    risk: IntentRisk;
+    metadata: Record<string, unknown>;
+}
+type ConstraintKind = 'required_param' | 'type_check' | 'range' | 'pattern' | 'temporal' | 'spatial' | 'authority' | 'safety' | 'custom';
+interface IntentConstraint {
+    kind: ConstraintKind;
+    field: string;
+    description: string;
+    satisfied: boolean;
+    value?: unknown;
+    expected?: unknown;
+}
+interface AlternativeIntent {
+    intent: string;
+    confidence: number;
+    reason: string;
+}
+interface ClarificationQuestion {
+    id: string;
+    question: string;
+    field: string;
+    options?: string[];
+    required: boolean;
+}
+type RiskLevel = 'none' | 'low' | 'medium' | 'high' | 'critical';
+interface IntentRisk {
+    level: RiskLevel;
+    score: number;
+    factors: string[];
+}
+interface IntentParamSchema {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    required: boolean;
+    description?: string;
+    default?: unknown;
+    pattern?: string;
+    min?: number;
+    max?: number;
+    enum?: unknown[];
+}
+interface IntentSchema {
+    intent: string;
+    description: string;
+    params: IntentParamSchema[];
+    required_scopes?: string[];
+    risk_level: RiskLevel;
+    has_side_effects: boolean;
+    reversible: boolean;
+    related?: string[];
+    tags?: string[];
+}
+interface CompilationResult {
+    ok: boolean;
+    compiled?: CompiledIntent;
+    errors: CompilationError[];
+}
+interface CompilationError {
+    code: string;
+    message: string;
+    field?: string;
+}
+
+export type { AlternativeIntent as A, ClarificationQuestion as C, IntentConstraint as I, RiskLevel as R, CompilationError as a, CompilationResult as b, CompiledIntent as c, ConstraintKind as d, IntentParamSchema as e, IntentProposal as f, IntentRisk as g, IntentSchema as h };