@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-J32ZJZJH.js

@@ -0,0 +1,554 @@
+// src/parser/PipelineParser.ts
+var VALID_SOURCE_TYPES = /* @__PURE__ */ new Set([
+  "rest",
+  "stream",
+  "filesystem",
+  "database",
+  "mcp",
+  "list",
+  "user_input",
+  "stdout",
+  "webhook"
+]);
+var VALID_TRANSFORM_TYPES = /* @__PURE__ */ new Set([
+  "llm",
+  "mcp",
+  "http",
+  "field_mapping"
+]);
+var VALID_SINK_TYPES = /* @__PURE__ */ new Set([
+  "rest",
+  "webhook",
+  "mcp",
+  "filesystem",
+  "database",
+  "stdout",
+  "holo"
+]);
+function stripComments(source) {
+  const lines = source.split("\n");
+  return lines.map((line) => {
+    let inString = null;
+    for (let i = 0; i < line.length; i++) {
+      const ch = line[i];
+      if (inString) {
+        if (ch === inString && line[i - 1] !== "\\") inString = null;
+      } else if (ch === '"' || ch === "'") {
+        inString = ch;
+      } else if (ch === "/" && line[i + 1] === "/") {
+        return line.substring(0, i);
+      }
+    }
+    return line;
+  }).join("\n");
+}
+function parseDuration(value) {
+  const match = value.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) return void 0;
+  return { value: parseInt(match[1], 10), unit: match[2] };
+}
+function extractBlock(source, keyword, name) {
+  const results = [];
+  const namePattern = "(\\w+)";
+  const regex = new RegExp(`${keyword}\\s+${namePattern}\\s*\\{`, "g");
+  let match;
+  while ((match = regex.exec(source)) !== null) {
+    const blockName = match[1];
+    const startLine = source.substring(0, match.index).split("\n").length;
+    const startIdx = source.indexOf("{", match.index);
+    let depth = 1;
+    let i = startIdx + 1;
+    while (i < source.length && depth > 0) {
+      if (source[i] === "{") depth++;
+      if (source[i] === "}") depth--;
+      i++;
+    }
+    results.push({
+      content: source.substring(startIdx + 1, i - 1),
+      name: blockName,
+      startLine
+    });
+  }
+  return results;
+}
+function parseInlineObjectLiteral(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return void 0;
+  const inner = trimmed.slice(1, -1).trim();
+  if (!inner) return {};
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  let inQuote = null;
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    const prev = i > 0 ? inner[i - 1] : "";
+    if (inQuote) {
+      current += ch;
+      if (ch === inQuote && prev !== "\\") inQuote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inQuote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "{" || ch === "[") depth++;
+    if (ch === "}" || ch === "]") depth--;
+    if (ch === "," && depth === 0) {
+      if (current.trim()) parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) parts.push(current.trim());
+  const out = {};
+  for (const part of parts) {
+    const idx = part.indexOf(":");
+    if (idx <= 0) return void 0;
+    const key = part.slice(0, idx).trim().replace(/^['"]|['"]$/g, "");
+    const rawVal = part.slice(idx + 1).trim();
+    let parsed = rawVal;
+    if (rawVal.startsWith('"') && rawVal.endsWith('"') || rawVal.startsWith("'") && rawVal.endsWith("'")) {
+      parsed = rawVal.slice(1, -1);
+    } else if (rawVal === "true") {
+      parsed = true;
+    } else if (rawVal === "false") {
+      parsed = false;
+    } else if (/^-?\d+$/.test(rawVal)) {
+      parsed = parseInt(rawVal, 10);
+    } else if (/^-?\d+\.\d+$/.test(rawVal)) {
+      parsed = parseFloat(rawVal);
+    } else if (rawVal.startsWith("{") && rawVal.endsWith("}")) {
+      parsed = parseInlineObjectLiteral(rawVal) ?? rawVal;
+    }
+    out[key] = parsed;
+  }
+  return out;
+}
+function splitPropertyLines(content) {
+  const lines = [];
+  let current = "";
+  let depth = 0;
+  let inQuote = null;
+  const flush = () => {
+    const trimmed = current.trim();
+    if (trimmed) lines.push(trimmed);
+    current = "";
+  };
+  for (let i = 0; i < content.length; i++) {
+    const ch = content[i];
+    const prev = i > 0 ? content[i - 1] : "";
+    if (inQuote) {
+      current += ch;
+      if (ch === inQuote && prev !== "\\") inQuote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      inQuote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "{" || ch === "[" || ch === "(") depth++;
+    if (ch === "}" || ch === "]" || ch === ")") depth = Math.max(0, depth - 1);
+    if (ch === "\n" || ch === "\r") {
+      flush();
+      continue;
+    }
+    if (depth === 0 && /\s/.test(ch) && current.trim() && /^\w+\s*:/.test(content.slice(i + 1))) {
+      flush();
+      continue;
+    }
+    current += ch;
+  }
+  flush();
+  return lines;
+}
+function parseProperties(content) {
+  const props = {};
+  const lines = splitPropertyLines(content);
+  let currentKey = null;
+  let multilineVal = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (currentKey !== null) {
+      multilineVal.push(line);
+      continue;
+    }
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const kvMatch = trimmed.match(/^(\w+)\s*:\s+(.+)$/);
+    if (kvMatch) {
+      const key = kvMatch[1];
+      let val = kvMatch[2].trim();
+      if (typeof val === "string" && val.startsWith("|")) {
+        currentKey = key;
+        multilineVal = [];
+        continue;
+      }
+      if (typeof val === "string" && val.endsWith(",")) {
+        val = val.slice(0, -1).trim();
+      }
+      if (typeof val === "string") {
+        const strVal = val;
+        const inlineObject = parseInlineObjectLiteral(strVal);
+        if (inlineObject) {
+          val = inlineObject;
+        } else if (strVal.startsWith('"') && strVal.endsWith('"')) {
+          val = strVal.slice(1, -1);
+        } else if (strVal.startsWith("'") && strVal.endsWith("'")) {
+          val = strVal.slice(1, -1);
+        } else if (strVal === "true") {
+          val = true;
+        } else if (strVal === "false") {
+          val = false;
+        } else if (/^\d+$/.test(strVal)) {
+          val = parseInt(strVal, 10);
+        } else if (/^\d+\.\d+$/.test(strVal)) {
+          val = parseFloat(strVal);
+        }
+      }
+      props[key] = val;
+    }
+  }
+  if (currentKey !== null) {
+    props[currentKey] = multilineVal.join("\n");
+  }
+  return props;
+}
+function parseNestedBlock(content, keyword) {
+  const blocks = extractBlock(content, keyword);
+  if (blocks.length > 0) {
+    return parseProperties(blocks[0].content);
+  }
+  const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const anonRegex = new RegExp(`(?:^|[^\\w.])${escaped}\\s*\\{`);
+  const match = anonRegex.exec(content);
+  if (!match) return void 0;
+  const startIdx = content.indexOf("{", match.index);
+  if (startIdx < 0) return void 0;
+  let depth = 1;
+  let i = startIdx + 1;
+  while (i < content.length && depth > 0) {
+    if (content[i] === "{") depth++;
+    if (content[i] === "}") depth--;
+    i++;
+  }
+  return parseProperties(content.substring(startIdx + 1, i - 1));
+}
+function parseFieldMappings(content) {
+  const mappings = [];
+  const lines = content.split("\n");
+  const pathPattern = "[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*(?:\\[\\])?";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const mapMatch = trimmed.match(
+      new RegExp(`^(${pathPattern})\\s*->\\s*(${pathPattern})(?:\\s*:\\s*(.+))?$`)
+    );
+    if (mapMatch) {
+      const transforms = mapMatch[3] ? mapMatch[3].split(":").map((t) => t.trim()).filter(Boolean) : [];
+      mappings.push({
+        from: mapMatch[1],
+        to: mapMatch[2],
+        transforms
+      });
+    }
+  }
+  return mappings;
+}
+function parseValidateFields(content) {
+  const fields = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const vMatch = trimmed.match(/^(\w+)\s*:\s*(.+)$/);
+    if (vMatch) {
+      const rules = vMatch[2].split(",").map((r) => r.trim()).filter(Boolean);
+      fields.push({ field: vMatch[1], rules });
+    }
+  }
+  return fields;
+}
+function parseBranchRoutes(content) {
+  const routes = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const whenMatch = trimmed.match(/^when\s+(.+?)\s*->\s*sink\s+(\w+)$/);
+    if (whenMatch) {
+      routes.push({ condition: whenMatch[1], sinkName: whenMatch[2] });
+      continue;
+    }
+    const defaultMatch = trimmed.match(/^default\s*->\s*sink\s+(\w+)$/);
+    if (defaultMatch) {
+      routes.push({ condition: "default", sinkName: defaultMatch[1] });
+    }
+  }
+  return routes;
+}
+function parseStringArray(content) {
+  const match = content.match(/\[([\s\S]*?)\]/);
+  if (!match) return [];
+  return match[1].split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+}
+function parsePipeline(source) {
+  const errors = [];
+  const clean = stripComments(source);
+  const pipelineBlocks = extractBlock(clean, "pipeline");
+  if (pipelineBlocks.length === 0) {
+    const quotedMatch = clean.match(/pipeline\s+["']([^"']+)["']\s*\{/);
+    if (!quotedMatch) {
+      return { success: false, errors: [{ message: "No pipeline block found" }] };
+    }
+    const startIdx = clean.indexOf("{", quotedMatch.index);
+    let depth = 1;
+    let i = startIdx + 1;
+    while (i < clean.length && depth > 0) {
+      if (clean[i] === "{") depth++;
+      if (clean[i] === "}") depth--;
+      i++;
+    }
+    const pipelineContent = clean.substring(startIdx + 1, i - 1);
+    return parsePipelineContent(quotedMatch[1], pipelineContent, errors);
+  }
+  return parsePipelineContent(pipelineBlocks[0].name, pipelineBlocks[0].content, errors);
+}
+function parsePipelineContent(name, content, errors) {
+  const invalidKeywords = [
+    "environment",
+    "spatial_group",
+    "object",
+    "orb",
+    "theme",
+    "light",
+    "camera",
+    "audio",
+    "zone",
+    "timeline",
+    "particle_system",
+    "effects",
+    "ui",
+    "npc",
+    "quest",
+    "dialogue",
+    "ability",
+    "achievement",
+    "talent_tree",
+    "behavior",
+    "state_machine",
+    "shape",
+    "terrain",
+    "waypoints",
+    "spawn_group",
+    "composition",
+    "constraint",
+    "sub_orb",
+    "norm",
+    "metanorm"
+  ];
+  const contentForKeywordCheck = content.replace(/"(?:\\.|[^"\\])*"/g, '""').replace(/'(?:\\.|[^'\\])*'/g, "''").replace(/`(?:\\.|[^`\\])*`/g, "``").replace(/template:\s*\|[\s\S]*?(?=\n\s*\})/g, 'template: ""');
+  for (const keyword of invalidKeywords) {
+    if (new RegExp(`\\b${keyword}\\b`).test(contentForKeywordCheck)) {
+      errors.push({
+        message: `SyntaxError: '${keyword}' is not valid in a pipeline context. Use .holo for spatial compositions or .hsplus for behaviors.`
+      });
+    }
+  }
+  if (/\btemplate\s+\w+\s*\{/.test(contentForKeywordCheck)) {
+    errors.push({
+      message: "SyntaxError: 'template' is not valid in a pipeline context. Use .holo for spatial compositions or .hsplus for behaviors."
+    });
+  }
+  const props = parseProperties(content);
+  const schedule = typeof props.schedule === "string" ? props.schedule : void 0;
+  const timeout = typeof props.timeout === "string" ? parseDuration(props.timeout) : void 0;
+  let retry;
+  const retryBlock = parseNestedBlock(content, "retry");
+  if (retryBlock) {
+    retry = {
+      max: typeof retryBlock.max === "number" ? retryBlock.max : 3,
+      backoff: retryBlock.backoff || "exponential"
+    };
+  }
+  const paramsBlock = parseNestedBlock(content, "params");
+  const params = paramsBlock;
+  const sources = [];
+  for (const block of extractBlock(content, "source")) {
+    const p = parseProperties(block.content);
+    const type = typeof p.type === "string" ? p.type : "rest";
+    if (!VALID_SOURCE_TYPES.has(type)) {
+      errors.push({
+        message: `Source "${block.name}" has unsupported type "${type}"`,
+        line: block.startLine,
+        block: block.name
+      });
+    }
+    sources.push({
+      kind: "source",
+      name: block.name,
+      type,
+      endpoint: p.endpoint,
+      path: p.path,
+      pattern: p.pattern,
+      since: p.since,
+      method: p.method,
+      auth: parseNestedBlock(block.content, "auth"),
+      pagination: parseNestedBlock(block.content, "pagination"),
+      properties: p
+    });
+  }
+  const transforms = [];
+  for (const block of extractBlock(content, "transform")) {
+    const p = parseProperties(block.content);
+    const mappings = parseFieldMappings(block.content);
+    const hasType = p.type !== void 0;
+    const type = hasType ? String(p.type) : mappings.length > 0 ? "field_mapping" : void 0;
+    if (!type) {
+      errors.push({
+        message: `Transform "${block.name}" missing type or field mappings`,
+        line: block.startLine,
+        block: block.name
+      });
+    } else if (!VALID_TRANSFORM_TYPES.has(type)) {
+      errors.push({
+        message: `Transform "${block.name}" has unsupported type "${type}"`,
+        line: block.startLine,
+        block: block.name
+      });
+    }
+    transforms.push({
+      kind: "transform",
+      name: block.name,
+      type,
+      mappings: mappings.length > 0 ? mappings : void 0,
+      model: p.model,
+      prompt: p.prompt,
+      input: p.input,
+      output: p.output,
+      server: p.server,
+      tool: p.tool,
+      args: p.args,
+      method: p.method,
+      url: p.url,
+      timeout: typeof p.timeout === "string" ? parseDuration(p.timeout) : void 0,
+      where: p.where,
+      properties: p
+    });
+  }
+  const filters = [];
+  for (const block of extractBlock(content, "filter")) {
+    const p = parseProperties(block.content);
+    if (!p.where) {
+      errors.push({
+        message: `Filter "${block.name}" missing 'where' clause`,
+        line: block.startLine,
+        block: block.name
+      });
+    }
+    filters.push({
+      kind: "filter",
+      name: block.name,
+      where: p.where || ""
+    });
+  }
+  const validates = [];
+  for (const block of extractBlock(content, "validate")) {
+    validates.push({
+      kind: "validate",
+      name: block.name,
+      fields: parseValidateFields(block.content)
+    });
+  }
+  const merges = [];
+  for (const block of extractBlock(content, "merge")) {
+    const p = parseProperties(block.content);
+    const fromArr = typeof p.from === "string" ? parseStringArray(p.from) : [];
+    merges.push({
+      kind: "merge",
+      name: block.name,
+      from: fromArr,
+      dedup: parseNestedBlock(block.content, "dedup"),
+      strategy: p.strategy
+    });
+  }
+  const branches = [];
+  for (const block of extractBlock(content, "branch")) {
+    branches.push({
+      kind: "branch",
+      name: block.name,
+      routes: parseBranchRoutes(block.content)
+    });
+  }
+  const sinks = [];
+  for (const block of extractBlock(content, "sink")) {
+    const p = parseProperties(block.content);
+    const type = typeof p.type === "string" ? p.type : "rest";
+    if (!VALID_SINK_TYPES.has(type)) {
+      errors.push({
+        message: `Sink "${block.name}" has unsupported type "${type}"`,
+        line: block.startLine,
+        block: block.name
+      });
+    }
+    sinks.push({
+      kind: "sink",
+      name: block.name,
+      type,
+      endpoint: p.endpoint,
+      path: p.path,
+      method: p.method,
+      auth: parseNestedBlock(block.content, "auth"),
+      batch: parseNestedBlock(block.content, "batch"),
+      onError: parseNestedBlock(block.content, "on_error"),
+      format: p.format,
+      append: p.append,
+      server: p.server,
+      tool: p.tool,
+      args: p.args,
+      template: p.template,
+      hash: p.hash,
+      properties: p
+    });
+  }
+  const steps = [
+    ...sources,
+    ...merges,
+    ...transforms,
+    ...filters,
+    ...validates,
+    ...branches,
+    ...sinks
+  ];
+  if (sources.length === 0) {
+    errors.push({ message: "Pipeline has no sources" });
+  }
+  if (sinks.length === 0) {
+    errors.push({ message: "Pipeline has no sinks" });
+  }
+  const pipeline = {
+    name,
+    schedule,
+    timeout,
+    retry,
+    params,
+    steps,
+    sources,
+    transforms,
+    filters,
+    validates,
+    merges,
+    branches,
+    sinks
+  };
+  return { success: errors.length === 0, pipeline, errors };
+}
+function isPipelineSource(source) {
+  return /pipeline\s+["']?\w/.test(source);
+}
+
+export { isPipelineSource, parsePipeline };
+//# sourceMappingURL=chunk-J32ZJZJH.js.map
+//# sourceMappingURL=chunk-J32ZJZJH.js.map