react-agentic 0.0.1 → 0.0.4

package/README.md

@@ -1,4 +1,4 @@
-# react-agentic
+# React Agentic
 
 **Build your company's GSD** — Enterprise-grade agentic workflows for Claude Code, authored in TypeScript.
 

package/dist/{chunk-263OAOFB.js → chunk-ILV2NZWS.js}

@@ -540,7 +540,7 @@ var init_text_extraction = __esm({
 // src/parser/utils/spread-resolution.ts
 import {
   Node as Node13,
-  SyntaxKind as SyntaxKind3
+  SyntaxKind as SyntaxKind4
 } from "ts-morph";
 var init_spread_resolution = __esm({
   "src/parser/utils/spread-resolution.ts"() {
@@ -551,7 +551,7 @@ var init_spread_resolution = __esm({
 // src/parser/utils/component-resolution.ts
 import {
   Node as Node14,
-  SyntaxKind as SyntaxKind4
+  SyntaxKind as SyntaxKind5
 } from "ts-morph";
 function resolveComponentImport2(componentName, sourceFile, visitedPaths) {
   const visited = visitedPaths ?? /* @__PURE__ */ new Set();
@@ -741,7 +741,7 @@ var init_type_resolution = __esm({
 import {
   Node as Node16
 } from "ts-morph";
-import { SyntaxKind as SyntaxKind5 } from "ts-morph";
+import { SyntaxKind as SyntaxKind6 } from "ts-morph";
 function extractInputObjectLiteral2(objLiteral, variables) {
   const properties = [];
   for (const prop of objLiteral.getProperties()) {
@@ -882,7 +882,7 @@ function analyzeRenderPropsChildren(element) {
 }
 function extractTypeArguments2(element) {
   const openingElement = Node16.isJsxElement(element) ? element.getOpeningElement() : element;
-  const typeRefNodes = openingElement.getDescendantsOfKind(SyntaxKind5.TypeReference);
+  const typeRefNodes = openingElement.getDescendantsOfKind(SyntaxKind6.TypeReference);
   if (typeRefNodes.length === 0) {
     return void 0;
   }
@@ -3975,19 +3975,65 @@ ${node.content}
     }
   }
   /**
-   * Emit RuntimeCallNode as bash code block
+   * Emit RuntimeCallNode as declarative table
    *
    * Output:
-   * ```bash
-   * CTX=$(node runtime.js fnName '{"args"}')
-   * ```
+   * **Runtime Call**: `functionName`
+   *
+   * | Argument | Value |
+   * |----------|-------|
+   * | phaseId | CTX.phaseId |
+   * | mode | If ctx.flags.gaps then "gap_closure", otherwise "standard" |
+   *
+   * **Output Variable**: RESULT
    */
   emitRuntimeCall(node) {
-    const argsJson = JSON.stringify(node.args);
-    const escapedArgs = argsJson.replace(/'/g, `'"'"'`);
-    return `\`\`\`bash
-${node.outputVar}=$(node runtime.js ${node.fnName} '${escapedArgs}')
-\`\`\``;
+    const lines = [];
+    lines.push(`**Runtime Call**: \`${node.fnName}\``);
+    lines.push("");
+    const argEntries = Object.entries(node.args);
+    if (argEntries.length > 0) {
+      lines.push("| Argument | Value |");
+      lines.push("|----------|-------|");
+      for (const [name, value] of argEntries) {
+        const formattedValue = this.formatArgValue(value);
+        const escapedValue = formattedValue.replace(/\|/g, "\\|");
+        lines.push(`| ${name} | ${escapedValue} |`);
+      }
+      lines.push("");
+    }
+    lines.push(`**Output Variable**: ${node.outputVar}`);
+    return lines.join("\n");
+  }
+  /**
+   * Format a RuntimeCallArgValue for display in the arguments table
+   */
+  formatArgValue(value) {
+    switch (value.type) {
+      case "literal":
+        if (value.value === null) return "null";
+        if (typeof value.value === "string") return `"${value.value}"`;
+        return String(value.value);
+      case "runtimeVarRef": {
+        const { varName, path: path5 } = value.ref;
+        if (path5.length === 0) {
+          return varName;
+        }
+        return `${varName}.${path5.join(".")}`;
+      }
+      case "expression":
+        return value.description;
+      case "json": {
+        if (Array.isArray(value.value)) {
+          const items = value.value.map((v) => this.formatArgValue(v));
+          return `[${items.join(", ")}]`;
+        }
+        const entries = Object.entries(value.value).map(([k, v]) => `${k}: ${this.formatArgValue(v)}`);
+        return `{ ${entries.join(", ")} }`;
+      }
+      default:
+        return String(value);
+    }
   }
   /**
    * Emit IfNode as prose conditional with jq
@@ -5277,7 +5323,7 @@ function markRuntimeFnUsed(wrapperName, ctx) {
 import { Node as Node29 } from "ts-morph";
 
 // src/parser/transformers/runtime-utils.ts
-import { Node as Node6 } from "ts-morph";
+import { Node as Node6, SyntaxKind as SyntaxKind2 } from "ts-morph";
 function getAttributeValue2(element, attrName) {
   const attr = element.getAttribute(attrName);
   if (!attr || !Node6.isJsxAttribute(attr)) return void 0;
@@ -5414,6 +5460,161 @@ function extractJsonValue(expr) {
   }
   return expr.getText();
 }
+function describeExpression(expr, ctx) {
+  if (Node6.isConditionalExpression(expr)) {
+    const condition = expr.getCondition();
+    const whenTrue = expr.getWhenTrue();
+    const whenFalse = expr.getWhenFalse();
+    const condDesc = describeExpressionPart(condition, ctx);
+    const trueVal = describeExpressionValue(whenTrue, ctx);
+    const falseVal = describeExpressionValue(whenFalse, ctx);
+    return `If ${condDesc} then ${trueVal}, otherwise ${falseVal}`;
+  }
+  if (Node6.isBinaryExpression(expr)) {
+    const left = expr.getLeft();
+    const right = expr.getRight();
+    const op = expr.getOperatorToken().getText();
+    const leftDesc = describeExpressionPart(left, ctx);
+    const rightDesc = describeExpressionValue(right, ctx);
+    switch (op) {
+      case "===":
+      case "==":
+        return `${leftDesc} equals ${rightDesc}`;
+      case "!==":
+      case "!=":
+        return `${leftDesc} does not equal ${rightDesc}`;
+      case "&&":
+        return `${leftDesc} AND ${describeExpressionPart(right, ctx)}`;
+      case "||":
+        return `${leftDesc} OR ${describeExpressionPart(right, ctx)}`;
+      case ">":
+        return `${leftDesc} is greater than ${rightDesc}`;
+      case ">=":
+        return `${leftDesc} is at least ${rightDesc}`;
+      case "<":
+        return `${leftDesc} is less than ${rightDesc}`;
+      case "<=":
+        return `${leftDesc} is at most ${rightDesc}`;
+      default:
+        return expr.getText();
+    }
+  }
+  if (Node6.isPrefixUnaryExpression(expr)) {
+    const opToken = expr.getOperatorToken();
+    const operand = expr.getOperand();
+    if (opToken === SyntaxKind2.ExclamationToken) {
+      return `NOT ${describeExpressionPart(operand, ctx)}`;
+    }
+  }
+  return expr.getText();
+}
+function describeExpressionPart(expr, ctx) {
+  const ref = parseRuntimeVarRef(expr, ctx);
+  if (ref) {
+    const path5 = ref.path.length === 0 ? ref.varName : `${ref.varName}.${ref.path.join(".")}`;
+    return path5;
+  }
+  if (Node6.isBinaryExpression(expr)) {
+    return describeExpression(expr, ctx);
+  }
+  return expr.getText();
+}
+function describeExpressionValue(expr, ctx) {
+  if (Node6.isStringLiteral(expr)) {
+    return `"${expr.getLiteralValue()}"`;
+  }
+  if (Node6.isNumericLiteral(expr)) {
+    return expr.getLiteralText();
+  }
+  if (Node6.isTrueLiteral(expr)) {
+    return "true";
+  }
+  if (Node6.isFalseLiteral(expr)) {
+    return "false";
+  }
+  if (Node6.isNullLiteral(expr)) {
+    return "null";
+  }
+  const ref = parseRuntimeVarRef(expr, ctx);
+  if (ref) {
+    const path5 = ref.path.length === 0 ? ref.varName : `${ref.varName}.${ref.path.join(".")}`;
+    return path5;
+  }
+  return expr.getText();
+}
+function extractRuntimeCallArg(expr, ctx) {
+  const ref = parseRuntimeVarRef(expr, ctx);
+  if (ref) {
+    return { type: "runtimeVarRef", ref };
+  }
+  if (Node6.isStringLiteral(expr)) {
+    return { type: "literal", value: expr.getLiteralValue() };
+  }
+  if (Node6.isNumericLiteral(expr)) {
+    return { type: "literal", value: Number(expr.getLiteralText()) };
+  }
+  if (Node6.isTrueLiteral(expr)) {
+    return { type: "literal", value: true };
+  }
+  if (Node6.isFalseLiteral(expr)) {
+    return { type: "literal", value: false };
+  }
+  if (Node6.isNullLiteral(expr)) {
+    return { type: "literal", value: null };
+  }
+  if (Node6.isNoSubstitutionTemplateLiteral(expr)) {
+    return { type: "literal", value: expr.getLiteralValue() };
+  }
+  if (Node6.isObjectLiteralExpression(expr)) {
+    const nested = {};
+    for (const prop of expr.getProperties()) {
+      if (Node6.isPropertyAssignment(prop)) {
+        const name = prop.getName();
+        const value = prop.getInitializer();
+        if (value) {
+          nested[name] = extractRuntimeCallArg(value, ctx);
+        }
+      }
+    }
+    return { type: "json", value: nested };
+  }
+  if (Node6.isArrayLiteralExpression(expr)) {
+    const items = expr.getElements().map((el) => extractRuntimeCallArg(el, ctx));
+    return { type: "json", value: items };
+  }
+  if (Node6.isConditionalExpression(expr) || Node6.isBinaryExpression(expr) || Node6.isPrefixUnaryExpression(expr)) {
+    return {
+      type: "expression",
+      source: expr.getText(),
+      description: describeExpression(expr, ctx)
+    };
+  }
+  return {
+    type: "expression",
+    source: expr.getText(),
+    description: expr.getText()
+  };
+}
+function extractRuntimeCallArgs(objExpr, ctx) {
+  if (!Node6.isObjectLiteralExpression(objExpr)) {
+    throw new Error("args must be an object literal");
+  }
+  const result = {};
+  for (const prop of objExpr.getProperties()) {
+    if (Node6.isPropertyAssignment(prop)) {
+      const name = prop.getName();
+      const value = prop.getInitializer();
+      if (value) {
+        result[name] = extractRuntimeCallArg(value, ctx);
+      }
+    } else if (Node6.isShorthandPropertyAssignment(prop)) {
+      const name = prop.getName();
+      const nameNode = prop.getNameNode();
+      result[name] = extractRuntimeCallArg(nameNode, ctx);
+    }
+  }
+  return result;
+}
 function getJsxElementName(node) {
   if (Node6.isJsxElement(node)) {
     return node.getOpeningElement().getTagNameNode().getText();
@@ -5447,11 +5648,11 @@ function processIfElseSiblings(jsxChildren, ifIndex, onElseFound) {
 }
 
 // src/parser/transformers/runtime-control.ts
-import { Node as Node7, SyntaxKind as SyntaxKind2 } from "ts-morph";
+import { Node as Node7, SyntaxKind as SyntaxKind3 } from "ts-morph";
 function parseConditionExpression(node, ctx) {
   if (Node7.isPrefixUnaryExpression(node)) {
     const operatorText = node.getOperatorToken();
-    if (operatorText === SyntaxKind2.ExclamationToken) {
+    if (operatorText === SyntaxKind3.ExclamationToken) {
       const operand = node.getOperand();
       return {
         type: "not",
@@ -5701,7 +5902,7 @@ function transformRuntimeCall(node, ctx) {
   }
   let args;
   if (Node8.isObjectLiteralExpression(argsExpr)) {
-    args = extractJsonValue(argsExpr);
+    args = extractRuntimeCallArgs(argsExpr, ctx);
   } else {
     throw ctx.createError(
       `${wrapperName}.Call args must be an object literal`,
@@ -6727,10 +6928,24 @@ function transformRuntimeIndent(node, ctx) {
 }
 function transformRuntimeCodeBlock(node, ctx) {
   const openingElement = Node29.isJsxElement(node) ? node.getOpeningElement() : node;
-  const language = getAttributeValue2(openingElement, "lang") || getAttributeValue2(openingElement, "language");
+  let language = getAttributeValue2(openingElement, "lang") || getAttributeValue2(openingElement, "language");
   if (Node29.isJsxSelfClosingElement(node)) {
     return { kind: "codeBlock", language, content: "" };
   }
+  const children = node.getJsxChildren();
+  for (const child of children) {
+    if (Node29.isJsxElement(child) && getElementName2(child) === "code") {
+      const codeOpening = child.getOpeningElement();
+      const codeClassName = getAttributeValue2(codeOpening, "className");
+      const codeLanguage = codeClassName?.replace(/^language-/, "") || language;
+      const content2 = extractCodeContentWithProps(child, ctx);
+      return { kind: "codeBlock", language: codeLanguage, content: content2 };
+    }
+  }
+  const content = extractCodeContentWithProps(node, ctx);
+  return { kind: "codeBlock", language, content };
+}
+function extractCodeContentWithProps(node, ctx) {
   const parts = [];
   for (const child of node.getJsxChildren()) {
     if (Node29.isJsxText(child)) {
@@ -6793,7 +7008,7 @@ function transformRuntimeCodeBlock(node, ctx) {
       content = lines.map((line) => line.slice(minIndent)).join("\n");
     }
   }
-  return { kind: "codeBlock", language, content };
+  return content;
 }
 function transformToRuntimeBlock(node, ctx) {
   if (Node29.isJsxText(node)) {
@@ -7900,4 +8115,4 @@ export {
   getSourceCode,
   formatTranspileError
 };
-//# sourceMappingURL=chunk-263OAOFB.js.map
+//# sourceMappingURL=chunk-ILV2NZWS.js.map