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

package/dist/chunk-L45BSQDJ.js

@@ -0,0 +1,296 @@
+import {
+  registry
+} from "./chunk-ABCK4FWN.js";
+
+// ../../lib/skills/schema-compiler.ts
+function resolveDefinition(def) {
+  if (typeof def === "boolean") return null;
+  return def;
+}
+function formatLabel(key) {
+  return key.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function compileProperty(key, prop, required) {
+  const label = prop.title ?? formatLabel(key);
+  const description = prop.description;
+  const type = prop.type;
+  if (type === "array") {
+    const itemsDef = prop.items;
+    const items = itemsDef && !Array.isArray(itemsDef) ? resolveDefinition(itemsDef) : null;
+    if (items && Array.isArray(items.enum)) {
+      return {
+        key,
+        widget: "multi-select",
+        label,
+        description,
+        required,
+        constraints: {
+          options: items.enum,
+          minItems: prop.minItems,
+          maxItems: prop.maxItems
+        },
+        toFormValue: (v) => Array.isArray(v) ? v.map(String) : [],
+        fromFormValue: (v) => Array.isArray(v) ? v : []
+      };
+    }
+    if (items && items.type === "string") {
+      return {
+        key,
+        widget: "text",
+        label,
+        description: description ? `${description} (comma-separated)` : "Enter values separated by commas",
+        required,
+        constraints: {
+          minItems: prop.minItems,
+          maxItems: prop.maxItems
+        },
+        toFormValue: (v) => Array.isArray(v) ? v.join(", ") : typeof v === "string" ? v : "",
+        fromFormValue: (v) => {
+          if (Array.isArray(v)) return v;
+          if (typeof v === "string") {
+            return v.split(",").map((s) => s.trim()).filter(Boolean);
+          }
+          return [];
+        }
+      };
+    }
+    return {
+      error: `Field "${key}": array items type "${items?.type ?? "unknown"}" is not supported \u2014 use items.enum for multi-select or items.type: "string" for comma input`
+    };
+  }
+  if (type === "string" && Array.isArray(prop.enum)) {
+    return {
+      key,
+      widget: "select",
+      label,
+      description,
+      required,
+      constraints: { options: prop.enum },
+      toFormValue: (v) => typeof v === "string" ? v : "",
+      fromFormValue: (v) => v
+    };
+  }
+  if (type === "string" && (prop.maxLength ?? 0) > 500) {
+    return {
+      key,
+      widget: "textarea",
+      label,
+      description,
+      required,
+      constraints: {
+        minLength: prop.minLength,
+        maxLength: prop.maxLength
+      },
+      toFormValue: (v) => typeof v === "string" ? v : String(v ?? ""),
+      fromFormValue: (v) => v
+    };
+  }
+  if (type === "string") {
+    return {
+      key,
+      widget: "text",
+      label,
+      description,
+      required,
+      constraints: {
+        minLength: prop.minLength,
+        maxLength: prop.maxLength
+      },
+      toFormValue: (v) => typeof v === "string" ? v : String(v ?? ""),
+      fromFormValue: (v) => v
+    };
+  }
+  if (type === "number" || type === "integer") {
+    return {
+      key,
+      widget: "number",
+      label,
+      description,
+      required,
+      constraints: {
+        min: prop.minimum,
+        max: prop.maximum
+      },
+      toFormValue: (v) => typeof v === "number" ? v : 0,
+      fromFormValue: (v) => {
+        const n = Number(v);
+        if (Number.isNaN(n)) return 0;
+        return type === "integer" ? Math.round(n) : n;
+      }
+    };
+  }
+  if (type === "boolean") {
+    return {
+      key,
+      widget: "toggle",
+      label,
+      description,
+      required,
+      constraints: {},
+      toFormValue: (v) => v === true,
+      fromFormValue: (v) => v === true || v === "true"
+    };
+  }
+  if (type === "object") {
+    return healObjectField(key, prop, required);
+  }
+  return {
+    error: `Field "${key}": type "${type ?? "undefined"}" is not supported \u2014 use string, number, integer, boolean, array, or object`
+  };
+}
+function healObjectField(key, prop, required) {
+  const label = prop.title ?? formatLabel(key);
+  const description = prop.description;
+  const subProperties = prop.properties ? Object.keys(prop.properties) : [];
+  const hasProperties = subProperties.length > 0;
+  const entropy = hasProperties ? Math.log2(Math.max(2, subProperties.length)) * 2 + subProperties.length * 0.5 : 1;
+  const confidence = hasProperties ? 0.7 : description ? 0.5 : 0.3;
+  const lostDimensions = ["object schema enforcement"];
+  if (hasProperties) {
+    lostDimensions.push(
+      `nested structure (${subProperties.length} properties: ${subProperties.join(", ")})`
+    );
+    lostDimensions.push("per-property type constraints");
+    if (prop.required && Array.isArray(prop.required)) {
+      lostDimensions.push(`required-field enforcement (${prop.required.join(", ")})`);
+    }
+  }
+  let placeholder;
+  if (hasProperties && prop.properties) {
+    const example = {};
+    for (const [k, v] of Object.entries(prop.properties)) {
+      const resolved = resolveDefinition(v);
+      example[k] = resolved?.type === "number" || resolved?.type === "integer" ? "0" : resolved?.type === "boolean" ? "false" : "";
+    }
+    try {
+      placeholder = JSON.stringify(example, null, 2);
+    } catch {
+    }
+  }
+  return {
+    key,
+    widget: "textarea",
+    label,
+    description: description ? `${description} (JSON)` : `Enter ${formatLabel(key)} as JSON`,
+    required,
+    constraints: {
+      // Suggest a minimum for non-empty JSON objects
+      minLength: required ? 2 : void 0
+    },
+    toFormValue: (v) => {
+      if (typeof v === "string") return v;
+      if (v === null || v === void 0) return placeholder ?? "{}";
+      try {
+        return JSON.stringify(v, null, 2);
+      } catch {
+        return "{}";
+      }
+    },
+    fromFormValue: (v) => {
+      if (typeof v !== "string") return v;
+      const trimmed = v.trim();
+      if (!trimmed) return {};
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        return trimmed;
+      }
+    },
+    healingTrace: {
+      originalType: "object",
+      strategy: "json-textarea",
+      lostDimensions,
+      entropy,
+      confidence
+    }
+  };
+}
+function compileInputSchema(schema) {
+  const fields = [];
+  const errors = [];
+  const warnings = [];
+  if (schema.type !== "object" || !schema.properties) {
+    return {
+      fields,
+      errors: ["inputSchema must be type: 'object' with properties"],
+      warnings: []
+    };
+  }
+  const required = new Set(
+    Array.isArray(schema.required) ? schema.required : []
+  );
+  for (const [key, propDef] of Object.entries(schema.properties)) {
+    const prop = resolveDefinition(propDef);
+    if (!prop) {
+      errors.push(`Property "${key}" is a boolean schema \u2014 skipped`);
+      continue;
+    }
+    const result = compileProperty(key, prop, required.has(key));
+    if ("error" in result) {
+      errors.push(result.error);
+    } else {
+      fields.push(result);
+      if (result.healingTrace) {
+        const t = result.healingTrace;
+        warnings.push(
+          `Field "${key}": type "${t.originalType}" healed to ${t.strategy} (entropy: ${t.entropy.toFixed(1)} bits, lost: ${t.lostDimensions.join("; ")})`
+        );
+      }
+    }
+  }
+  return { fields, errors, warnings };
+}
+
+// ../../lib/skills/registry.ts
+var SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SKILL_REGISTRY = /* @__PURE__ */ new Map();
+function registerSkill(skill) {
+  const slug = skill.skill.slug;
+  if (!slug || !SLUG_PATTERN.test(slug)) {
+    console.warn(
+      `[Skills] Rejected registration: invalid slug "${slug}" \u2014 must be lowercase alphanumeric with hyphens`
+    );
+    return;
+  }
+  if (skill.skill.inputSchema) {
+    const compiled = compileInputSchema(skill.skill.inputSchema);
+    if (compiled.errors.length > 0) {
+      console.warn(`[Skills] Schema errors for "${slug}":`, compiled.errors.join("; "));
+    }
+    if (compiled.warnings.length > 0) {
+      console.warn(`[Skills] Schema healing for "${slug}":`, compiled.warnings.join("; "));
+    }
+  }
+  SKILL_REGISTRY.set(slug, skill);
+  registry.register(skill, "skill", "system", skill.skill.tags);
+}
+function getSkill(slug) {
+  return SKILL_REGISTRY.get(slug);
+}
+function getAllSkills() {
+  return Array.from(SKILL_REGISTRY.values());
+}
+function getSkillsByCategory(category) {
+  return getAllSkills().filter((s) => s.skill.category === category);
+}
+function getSkillCount() {
+  return SKILL_REGISTRY.size;
+}
+var skillsLoadPromise = null;
+async function ensureSkillsRegistered() {
+  if (SKILL_REGISTRY.size > 0) return;
+  if (!skillsLoadPromise) {
+    skillsLoadPromise = import("./skills-VN7IN7SJ.js").then(() => {
+    });
+  }
+  await skillsLoadPromise;
+}
+
+export {
+  registerSkill,
+  getSkill,
+  getAllSkills,
+  getSkillsByCategory,
+  getSkillCount,
+  ensureSkillsRegistered
+};